@pisell/pisellos 0.10.7 → 0.10.9

package/lib/model/strategy/adapter/dataVariant/evaluator.d.ts

@@ -3,7 +3,7 @@ import type { ConditionScope, DataVariantBusinessData, DataVariantMenu, DataVari
 /**
  * Data Variant 评估器。
  *
- * 当前阶段只提供策略模型能力和示例验证，不接入 ProductList 业务链路。
+ * OS Server 商品路由开启时由 ProductsModule 调用；路由关闭时由 ProductList 在远端响应后调用。
  */
 export declare class DataVariantEvaluator {
     private adapter;
@@ -17,7 +17,7 @@ export declare class DataVariantEvaluator {
     /**
      * 批量解析商品 Data Variant。
      *
-     * 先执行全局预计算，再只针对商品自身 data_variants 引用到的规则做商品级判断。
+     * 优先使用商品 metadata.data_variant_ids；缺少权威命中结果时才执行本地策略判断。
      */
     resolveProducts(businessData: DataVariantBusinessData): ResolvedDataVariantResult;
     /**
@@ -34,8 +34,24 @@ export declare class DataVariantEvaluator {
      * 这里不依赖餐牌，只读取策略配置和调用方传入的 scheduleList。
      */
     buildScheduleTimePoints(strategyConfigs: StrategyConfig<DataVariantRuleMetadata>[], scheduleList: NonNullable<DataVariantBusinessData['scheduleList']>): string[];
+    /**
+     * 判断商品（含套餐子商品）是否仍需要本地执行策略条件。
+     * metadata.data_variant_ids 只要是数组，即使为空，也表示接口已经给出权威命中结果。
+     */
+    private requiresLocalStrategyEvaluation;
+    /**
+     * 将接口返回的高 -> 低优先级 Variant ID 转成数值优先级。
+     * 返回 null 表示接口没有提供该字段；空 Map 表示已计算但没有任何命中。
+     */
+    private getAuthoritativeVariantPriorities;
+    private normalizeDataVariantId;
     private buildGlobalEffectiveRuleMap;
     private resolveProduct;
+    /**
+     * 多货币 Data Variant 只生成候选列表，不参与商品字段覆盖。
+     * rule_id=0 是无条件默认价；同币种命中的条件价优先于默认价。
+     */
+    private resolveSettlementOptions;
     /**
      * 解析套餐子商品上的 Data Variant 覆盖。
      *

package/lib/model/strategy/adapter/dataVariant/evaluator.js

@@ -43,7 +43,7 @@ var DataVariantEvaluator = class {
   /**
    * 批量解析商品 Data Variant。
    *
-   * 先执行全局预计算，再只针对商品自身 data_variants 引用到的规则做商品级判断。
+   * 优先使用商品 metadata.data_variant_ids；缺少权威命中结果时才执行本地策略判断。
    */
   resolveProducts(businessData) {
     const strategyConfigs = businessData.strategyConfigs ? this.normalizeStrategyConfigs(businessData.strategyConfigs) : this.strategyConfigs;
@@ -52,11 +52,17 @@ var DataVariantEvaluator = class {
       strategyConfigs,
       businessData.scheduleList || []
     );
-    const { globalEffectiveRuleMap, rawResults } = this.buildGlobalEffectiveRuleMap(
+    const shouldEvaluateStrategies = businessData.products.some(
+      (product) => this.requiresLocalStrategyEvaluation(product)
+    );
+    const { globalEffectiveRuleMap, rawResults } = shouldEvaluateStrategies ? this.buildGlobalEffectiveRuleMap(
       strategyConfigs,
       businessData,
       menuScopeMap
-    );
+    ) : {
+      globalEffectiveRuleMap: /* @__PURE__ */ new Map(),
+      rawResults: []
+    };
     const products = businessData.products.map((product) => {
       const resolvedProduct = this.resolveProduct(
         product,
@@ -154,6 +160,56 @@ var DataVariantEvaluator = class {
     );
     return this.extractTimePointsFromSchedules(matchedSchedules);
   }
+  /**
+   * 判断商品（含套餐子商品）是否仍需要本地执行策略条件。
+   * metadata.data_variant_ids 只要是数组，即使为空，也表示接口已经给出权威命中结果。
+   */
+  requiresLocalStrategyEvaluation(product) {
+    const dataVariants = this.getProductDataVariants(product);
+    const hasConditionalVariant = dataVariants.some(
+      (variant) => Number(variant.data_variant_rule_id) !== 0
+    );
+    if (hasConditionalVariant && this.getAuthoritativeVariantPriorities(product) === null) {
+      return true;
+    }
+    const bundleGroups = Array.isArray(product.bundle_group) ? product.bundle_group : [];
+    return bundleGroups.some((group) => {
+      const bundleItems = Array.isArray(group == null ? void 0 : group.bundle_item) ? group.bundle_item : [];
+      return bundleItems.some(
+        (item) => this.requiresLocalStrategyEvaluation(
+          this.toBundleItemDataVariantProduct(item)
+        )
+      );
+    });
+  }
+  /**
+   * 将接口返回的高 -> 低优先级 Variant ID 转成数值优先级。
+   * 返回 null 表示接口没有提供该字段；空 Map 表示已计算但没有任何命中。
+   */
+  getAuthoritativeVariantPriorities(product) {
+    var _a;
+    const rawIds = (_a = product == null ? void 0 : product.metadata) == null ? void 0 : _a.data_variant_ids;
+    if (!Array.isArray(rawIds))
+      return null;
+    const orderedIds = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const rawId of rawIds) {
+      const id = this.normalizeDataVariantId(rawId);
+      if (id === null || seen.has(id))
+        continue;
+      seen.add(id);
+      orderedIds.push(id);
+    }
+    return new Map(
+      orderedIds.map((id, index) => [id, orderedIds.length - index])
+    );
+  }
+  normalizeDataVariantId(value) {
+    if (value === void 0 || value === null)
+      return null;
+    const normalized = String(value).trim();
+    return normalized || null;
+  }
   buildGlobalEffectiveRuleMap(strategyConfigs, businessData, menuScopeMap) {
     const globalEffectiveRuleMap = /* @__PURE__ */ new Map();
     const rawResults = [];
@@ -182,7 +238,26 @@ var DataVariantEvaluator = class {
     if (!dataVariants.length)
       return product;
     const matchedVariants = [];
+    const authoritativeVariantPriorities = this.getAuthoritativeVariantPriorities(product);
+    const settlementVariants = dataVariants.filter(
+      (variant) => variant.business_type === "multi_currency_settlement" && variant.status === "enable"
+    );
     for (const variant of dataVariants) {
+      if (variant.business_type === "multi_currency_settlement")
+        continue;
+      if (authoritativeVariantPriorities !== null) {
+        const variantId = this.normalizeDataVariantId(variant.id);
+        const priority = variantId === null ? void 0 : authoritativeVariantPriorities.get(variantId);
+        if (priority === void 0)
+          continue;
+        matchedVariants.push({
+          ruleId: String(variant.data_variant_rule_id),
+          priority,
+          data: variant.data || {},
+          variant
+        });
+        continue;
+      }
       const rule = globalEffectiveRuleMap.get(
         String(variant.data_variant_rule_id)
       );
@@ -198,9 +273,91 @@ var DataVariantEvaluator = class {
         variant
       });
     }
-    if (!matchedVariants.length)
-      return product;
-    return this.mergeMatchedVariants(product, matchedVariants);
+    const resolvedProduct = matchedVariants.length ? this.mergeMatchedVariants(product, matchedVariants) : product;
+    const availableSettlementOptions = this.resolveSettlementOptions(
+      settlementVariants,
+      product,
+      businessData,
+      globalEffectiveRuleMap,
+      menuScopeMap,
+      authoritativeVariantPriorities
+    );
+    if (!settlementVariants.length)
+      return resolvedProduct;
+    return {
+      ...resolvedProduct,
+      available_settlement_options: availableSettlementOptions
+    };
+  }
+  /**
+   * 多货币 Data Variant 只生成候选列表，不参与商品字段覆盖。
+   * rule_id=0 是无条件默认价；同币种命中的条件价优先于默认价。
+   */
+  resolveSettlementOptions(variants, product, businessData, globalEffectiveRuleMap, menuScopeMap, authoritativeVariantPriorities) {
+    if (!variants.length)
+      return [];
+    const candidates = variants.flatMap((variant) => {
+      var _a, _b;
+      const settlement = (_a = variant.data) == null ? void 0 : _a.multi_currency_settlement;
+      if (!settlement || typeof settlement !== "object")
+        return [];
+      const ruleId = String(variant.data_variant_rule_id);
+      const isDefault = Number(variant.data_variant_rule_id) === 0;
+      const rule = isDefault ? void 0 : globalEffectiveRuleMap.get(ruleId);
+      const variantId = this.normalizeDataVariantId(variant.id);
+      const authoritativePriority = variantId === null ? void 0 : authoritativeVariantPriorities == null ? void 0 : authoritativeVariantPriorities.get(variantId);
+      let available;
+      let priority;
+      if (isDefault) {
+        available = true;
+        priority = Number.NEGATIVE_INFINITY;
+      } else if (authoritativeVariantPriorities !== null) {
+        available = authoritativePriority !== void 0;
+        priority = authoritativePriority ?? (rule == null ? void 0 : rule.priority) ?? Number.NEGATIVE_INFINITY;
+      } else {
+        available = Boolean(
+          rule && this.evaluateProductRules(
+            rule,
+            product,
+            businessData,
+            menuScopeMap
+          )
+        );
+        priority = (rule == null ? void 0 : rule.priority) ?? Number.NEGATIVE_INFINITY;
+      }
+      const settlementType = String(settlement.settlement_type || "");
+      const currencyProductId = this.toNumber(settlement.currency_product_id);
+      const settlementKey = settlementType === "virtual_currency" ? `virtual_currency:${currencyProductId || ""}` : settlementType || `variant:${variant.id ?? ruleId}`;
+      return [{
+        key: settlementKey,
+        priority,
+        isDefault,
+        option: {
+          ...settlement,
+          settlement_type: settlementType,
+          ...currencyProductId ? { currency_product_id: currencyProductId } : {},
+          price: String(((_b = variant.data) == null ? void 0 : _b.price) ?? "0"),
+          data_variant_id: variant.id,
+          data_variant_rule_id: variant.data_variant_rule_id,
+          available,
+          disabled_reason: available ? "" : String(
+            settlement.disabled_reason || "Not available for this purchase."
+          )
+        }
+      }];
+    });
+    const grouped = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const group = grouped.get(candidate.key) || [];
+      group.push(candidate);
+      grouped.set(candidate.key, group);
+    }
+    return Array.from(grouped.values()).map((group) => {
+      const matchedConditional = group.filter((candidate) => !candidate.isDefault && candidate.option.available).sort((a, b) => b.priority - a.priority)[0];
+      const defaultCandidate = group.find((candidate) => candidate.isDefault);
+      const unavailableCandidate = [...group].filter((candidate) => !candidate.option.available).sort((a, b) => b.priority - a.priority)[0];
+      return (matchedConditional || defaultCandidate || unavailableCandidate).option;
+    });
   }
   /**
    * 解析套餐子商品上的 Data Variant 覆盖。
@@ -262,7 +419,8 @@ var DataVariantEvaluator = class {
       product_variant_id: variantId,
       variant_id: variantId,
       collection: item.collection,
-      data_variants: item.data_variants
+      data_variants: item.data_variants,
+      metadata: item.metadata
     };
   }
   /**
@@ -501,6 +659,11 @@ var DataVariantEvaluator = class {
     }
     result._dataVariant = {
       appliedRuleIds,
+      appliedVariantIds: Array.from(
+        new Set(
+          [...sortedVariants].reverse().map((matched) => this.normalizeDataVariantId(matched.variant.id)).filter((id) => id !== null)
+        )
+      ),
       appliedFields: Array.from(appliedFields),
       original
     };

package/lib/model/strategy/adapter/dataVariant/type.d.ts

@@ -35,6 +35,10 @@ export interface DataVariantItem {
     module_data_id?: number;
     /** 关联策略模型 metadata.id / data_variant_rule.id */
     data_variant_rule_id: number | string;
+    /** 业务类型；多货币结算候选不会走普通字段覆盖 */
+    business_type?: 'multi_currency_settlement' | string;
+    /** 数据状态；多货币结算仅处理 enable 记录 */
+    status?: 'enable' | 'disable' | string;
     /** 命中策略后需要覆盖到商品上的字段 */
     data: Record<string, any>;
     created_at?: string | null;
@@ -53,11 +57,30 @@ export interface DataVariantProduct {
         id?: number | string;
         [key: string]: any;
     }>;
+    /**
+     * 商品接口已经完成规则计算时返回的命中结果。
+     * 数组按 Data Variant 优先级从高到低排列；空数组表示已计算但无命中。
+     */
+    metadata?: {
+        data_variant_ids?: Array<number | string>;
+        [key: string]: any;
+    };
     /** 后端 /product/query with dataVariants 返回的智能定价变体列表 */
     data_variants?: DataVariantItem[];
+    /** 当前上下文解析后的可选结算货币，不覆盖商品原始多货币配置 */
+    available_settlement_options?: AvailableSettlementOption[];
     _dataVariant?: DataVariantAppliedInfo;
     [key: string]: any;
 }
+export interface AvailableSettlementOption extends Record<string, any> {
+    settlement_type: 'legal_currency' | 'virtual_currency' | string;
+    currency_product_id?: number;
+    price: string;
+    data_variant_id?: number;
+    data_variant_rule_id: number | string;
+    available: boolean;
+    disabled_reason?: string;
+}
 /**
  * 餐牌商品配置项。
  */
@@ -131,6 +154,8 @@ export interface MatchedDataVariant {
  */
 export interface DataVariantAppliedInfo {
     appliedRuleIds: string[];
+    /** 本地策略实际应用的 Data Variant ID，按优先级从高到低排列。 */
+    appliedVariantIds?: Array<number | string>;
     appliedFields: string[];
     original: DataVariantProduct;
 }

package/lib/model/strategy/adapter/walletPass/evaluator.js

@@ -214,7 +214,6 @@ var WalletPassEvaluator = class {
         }
         const rawText = this.getText(reasonCode);
         const currency = failedField && AMOUNT_FIELDS.has(failedField) ? ((_g = (_f = this.otherParams) == null ? void 0 : _f.getData) == null ? void 0 : _g.call(_f, "shop_symbol")) || "" : "";
-        console.log(currency, "currency12345");
         const reason = thresholdValue !== void 0 ? formatReason(rawText, thresholdValue, currency) : rawText;
         results.push({
           voucher,
@@ -416,7 +415,6 @@ var WalletPassEvaluator = class {
    * 计算适用商品的总金额和数量
    */
   calculateApplicableProducts(products, applicableProductIds, deductTaxAndFee) {
-    console.log(products, "products1234");
     let total = 0;
     let count = 0;
     if (applicableProductIds !== null && applicableProductIds.length === 0) {

package/lib/model/strategy/adapter/walletPass/type.d.ts

@@ -26,6 +26,11 @@ export interface Voucher {
     recommended_usage_amount: number;
     /** 后端计算推荐使用金额（仅商品） 不包含税费附加费 */
     recommended_pure_product_usage_amount: number;
+    /**
+     * 扫码资产自身可供前端重新计算的金额基准。
+     * 后端 recommended_usage_amount 会包含当前已选券上下文，取消勾选后不能继续把它当作资产永久上限。
+     */
+    _wallet_asset_recalculation_base_amount?: number;
     /** 实际抵扣金额 */
     actualDeduction: number;
     /** 抵扣详情 */

package/lib/model/strategy/adapter/walletPass/utils.js

@@ -43,6 +43,21 @@ __export(utils_exports, {
 });
 module.exports = __toCommonJS(utils_exports);
 var import_decimal = __toESM(require("decimal.js"));
+var DEFAULT_WALLET_PASS_CALCULATION_CONFIG = {
+  maxDeductionAmount: 99999,
+  maxUsagePerOrder: 0,
+  allowCrossProduct: true,
+  applicableProductLimit: 0,
+  deductTaxAndFee: true,
+  maxPassesPerItem: 0,
+  deductOptionPrice: false
+};
+function getWalletPassCalculationConfig(voucher) {
+  return {
+    ...DEFAULT_WALLET_PASS_CALCULATION_CONFIG,
+    ...(voucher == null ? void 0 : voucher.config) || {}
+  };
+}
 var getProductQuantity = (product) => {
   return product.quantity || product.product_quantity || 1;
 };
@@ -105,9 +120,15 @@ function applyMaxPassUsageIncrements(usageMap, walletPassProductId, maxPassesPer
   });
 }
 var getRecommendedAmount = (voucher) => {
-  console.log("voucher312", voucher);
   const { config, recommended_usage_amount, recommended_pure_product_usage_amount } = voucher;
   const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
+  const rawRecalculationBaseAmount = voucher._wallet_asset_recalculation_base_amount;
+  if (rawRecalculationBaseAmount !== void 0 && rawRecalculationBaseAmount !== null) {
+    const recalculationBaseAmount = Number(rawRecalculationBaseAmount);
+    if (Number.isFinite(recalculationBaseAmount) && recalculationBaseAmount >= 0) {
+      return recalculationBaseAmount;
+    }
+  }
   return deductTaxAndFee ? recommended_usage_amount : recommended_pure_product_usage_amount ?? recommended_usage_amount;
 };
 var getApplicableProductIds = (voucher) => {
@@ -145,7 +166,6 @@ var getApplicableProducts = (voucher, productsData) => {
   return productsData.filter((p) => applicableProductIds.includes(p.product_id));
 };
 function processVouchers(applicableVouchers, orderTotalAmount, products) {
-  console.log(products, "products123");
   const productsCopy = expandProductsWithBundleItems(products, true);
   let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
   const getItemPassUsage = (usageMap, walletPassProductId, lineKey) => {
@@ -218,7 +238,7 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
     return import_decimal.default.min(baseAmount, finalApplicableAmount, remainingOrderAmount);
   };
   const isVoucherAvailable = (voucher, productsData, usedVoucherCounts2, itemPassUsage) => {
-    const { config, id, product_id } = voucher;
+    const { config, product_id } = voucher;
     const recommendedAmount = getRecommendedAmount(voucher);
     if (recommendedAmount <= 0) {
       return { isAvailable: false, reasonCode: "not_meet_the_required_conditions" };
@@ -453,6 +473,7 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
   const productsForCalc = expandProductsWithBundleItems(products, true);
   let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
   const selectedWithDetails = [];
+  const usedVoucherCounts = /* @__PURE__ */ new Map();
   const itemPassUsageMap = /* @__PURE__ */ new Map();
   const getItemPassUsageRecalc = (walletPassProductId, lineKey) => {
     var _a;
@@ -469,8 +490,29 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     });
   };
   selectedVouchers.forEach((selectedVoucher) => {
-    const { config, id } = selectedVoucher;
-    const { maxDeductionAmount, allowCrossProduct, applicableProductLimit, deductTaxAndFee = true, maxPassesPerItem = 0 } = config;
+    const { product_id } = selectedVoucher;
+    const config = getWalletPassCalculationConfig(selectedVoucher);
+    const {
+      maxDeductionAmount,
+      maxUsagePerOrder,
+      allowCrossProduct,
+      applicableProductLimit,
+      deductTaxAndFee,
+      maxPassesPerItem
+    } = config;
+    const usedCount = usedVoucherCounts.get(product_id) || 0;
+    if (maxUsagePerOrder > 0 && usedCount >= maxUsagePerOrder) {
+      selectedWithDetails.push({
+        ...selectedVoucher,
+        config,
+        actualDeduction: 0,
+        deductionDetails: [],
+        _available_max_amount: 0,
+        _unified_available_status: 0,
+        reasonCode: "usage_limit_reached"
+      });
+      return;
+    }
     const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
     const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
     let applicableProducts = getApplicableProducts(
@@ -481,6 +523,7 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     if (applicableProducts.length === 0) {
       selectedWithDetails.push({
         ...selectedVoucher,
+        config,
         actualDeduction: 0,
         deductionDetails: [],
         _available_max_amount: 0,
@@ -558,6 +601,7 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     applyMaxPassUsageIncrements(itemPassUsageMap, selectedVoucher.product_id, maxPassesPerItem, deductionDetails);
     selectedWithDetails.push({
       ...selectedVoucher,
+      config,
       actualDeduction: totalDeducted.toNumber(),
       // 转换为数字
       deductionDetails,
@@ -565,12 +609,11 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       // 转换为数字
       _unified_available_status: totalDeducted.greaterThan(0) ? 1 : 0
     });
+    if (totalDeducted.greaterThan(0)) {
+      usedVoucherCounts.set(product_id, usedCount + 1);
+    }
   });
   const selectedIds = new Set(selectedVouchers.map((v) => v.id));
-  const usedVoucherCounts = /* @__PURE__ */ new Map();
-  selectedVouchers.forEach((v) => {
-    usedVoucherCounts.set(v.product_id, (usedVoucherCounts.get(v.product_id) || 0) + 1);
-  });
   const allWithUpdatedStatus = allVouchers.map((voucher) => {
     if (selectedIds.has(voucher.id)) {
       const selectedDetail = selectedWithDetails.find(
@@ -578,8 +621,15 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       );
       return selectedDetail || voucher;
     }
-    const { config, id, product_id } = voucher;
-    const { maxDeductionAmount, allowCrossProduct, applicableProductLimit, deductTaxAndFee = true, maxPassesPerItem = 0 } = config;
+    const { product_id } = voucher;
+    const config = getWalletPassCalculationConfig(voucher);
+    const {
+      maxDeductionAmount,
+      allowCrossProduct,
+      applicableProductLimit,
+      deductTaxAndFee,
+      maxPassesPerItem
+    } = config;
     const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
     const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
     const recommendedAmount = getRecommendedAmount(voucher);
@@ -663,6 +713,7 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     }
     return {
       ...voucher,
+      config,
       _available_max_amount: calculatedMaxAmount.toNumber(),
       // 转换为数字
       _unified_available_status: isAvailable ? 1 : 0,

package/lib/modules/BookingContext/utils/buildCacheItemFromOrderLine.js

@@ -149,7 +149,9 @@ function mapOrderBundleToOtherBundle(bundle) {
   return bundle.map((item) => {
     return {
       ...item,
-      original_price: item.original_price ?? item.bundle_selling_price ?? item.price
+      // 后端历史订单可能没有 original_price；此时 price 是折前毛价，
+      // bundle_selling_price 已包含折扣，不能把它当成编辑时的新原价。
+      original_price: item.original_price ?? item.product_price ?? item.price ?? item.bundle_selling_price
     };
   });
 }
@@ -200,6 +202,8 @@ function buildCacheItemFromOrderLine(input) {
   const productTitle = resolveProductTitle(product, booking, sourceProduct);
   const productCover = resolveProductCover(product, booking, sourceProduct);
   const productOptionString = (0, import_orderLineDisplay.buildProductOptionStringFromOrderLine)(product);
+  const hasBundle = Array.isArray(product.product_bundle) && product.product_bundle.length > 0;
+  const bundleEdit = product.bundle_edit ?? (hasBundle ? 0 : void 0);
   const other = {
     product_variant_id: product.product_variant_id ?? 0,
     option: (0, import_utils.getProductSkuOptions)(product),
@@ -232,6 +236,7 @@ function buildCacheItemFromOrderLine(input) {
       product.discount_list,
       (_c = product.metadata) == null ? void 0 : _c.product_discount_reason
     ) || void 0,
+    ...bundleEdit !== void 0 ? { bundle_edit: bundleEdit } : {},
     ...productOptionString ? { product_option_string: productOptionString } : {}
   };
   const manualDiscount = (product.discount_list || []).find((d) => (d == null ? void 0 : d.type) === "product");

package/lib/modules/BookingContext/utils/productExtend.js

@@ -83,12 +83,13 @@ function getTimeObj(params) {
   const { cacheItem, useStartTime, useDuration, ctx } = params;
   const isMultiDay = (0, import_serviceTimes.isMultiDayProduct)(cacheItem);
   const flexibleOption = getFlexibleOption({ cacheItem, useStartTime, ctx });
-  const baseSlices = (0, import_timeSlices.sliceDayIntoFiveMinutes)(
+  const {
+    timeSlices,
+    durationSlicesBasedOnTime
+  } = (0, import_timeSlices.sliceDayIntoFiveMinutes)(
     (_c = (_b = (_a = ctx == null ? void 0 : ctx.bookingConfig) == null ? void 0 : _a.config) == null ? void 0 : _b.basic) == null ? void 0 : _c.service_time,
     isMultiDay
   );
-  const timeSlices = [...baseSlices.timeSlices];
-  const durationSlicesBasedOnTime = [...baseSlices.durationSlicesBasedOnTime];
   if (flexibleOption) {
     durationSlicesBasedOnTime.unshift(flexibleOption);
   }

package/lib/modules/BookingContext/utils/timeSlices.js

@@ -38,10 +38,21 @@ __export(timeSlices_exports, {
 module.exports = __toCommonJS(timeSlices_exports);
 var import_dayjs = __toESM(require("dayjs"));
 var import_flexible = require("./flexible");
+var timeSlicesCache = /* @__PURE__ */ new Map();
+function copyTimeSlices(result) {
+  return {
+    timeSlices: [...result.timeSlices],
+    durationSlicesBasedOnTime: [...result.durationSlicesBasedOnTime]
+  };
+}
 function sliceDayIntoFiveMinutes(config, isDay) {
+  const timeSlice = config && config.value || 5;
+  const cacheKey = isDay ? "days" : `minutes:${timeSlice}`;
+  const cached = timeSlicesCache.get(cacheKey);
+  if (cached)
+    return copyTimeSlices(cached);
   const startTime = (0, import_dayjs.default)().startOf("day");
   const endTime = (0, import_dayjs.default)().endOf("day");
-  const timeSlice = config && config.value || 5;
   const timeSlices = [];
   const durationSlicesBasedOnTime = [];
   let currentTime = startTime;
@@ -58,7 +69,9 @@ function sliceDayIntoFiveMinutes(config, isDay) {
       });
       currentDay += 1;
     }
-    return { timeSlices, durationSlicesBasedOnTime };
+    const result2 = { timeSlices, durationSlicesBasedOnTime };
+    timeSlicesCache.set(cacheKey, result2);
+    return copyTimeSlices(result2);
   }
   while (currentTime.isBefore(endTime)) {
     timeSlices.push({
@@ -73,7 +86,9 @@ function sliceDayIntoFiveMinutes(config, isDay) {
     });
     currentTime = nextTime;
   }
-  return { timeSlices, durationSlicesBasedOnTime };
+  const result = { timeSlices, durationSlicesBasedOnTime };
+  timeSlicesCache.set(cacheKey, result);
+  return copyTimeSlices(result);
 }
 function findNextDuration(current, array, defaultValue) {
   if (defaultValue !== void 0 && defaultValue !== null)

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

@@ -44,6 +44,10 @@ export declare class CustomerModule extends BaseModule implements Module, Custom
      * 用于按 ID 补齐客户等内部查询，避免把临时的 num/searchParams 污染到滚动列表。
      */
     queryCustomerList(params?: ShopGetCustomerListParams): Promise<ICustomerListResponse>;
+    /**
+     * 查询单个客户详情，不写入 customerList / pagination 状态。
+     */
+    queryCustomerDetail(id: string | number): Promise<ShopCustomer | null>;
     /**
      * 获取客户列表
      * @param params 查询参数

package/lib/modules/Customer/index.js

@@ -201,6 +201,17 @@ var CustomerModule = class extends import_BaseModule.BaseModule {
       pageSize
     };
   }
+  /**
+   * 查询单个客户详情，不写入 customerList / pagination 状态。
+   */
+  async queryCustomerDetail(id) {
+    var _a;
+    const result = await this.request.get(`/customer/info/${id}`, {
+      with_trashed: 1
+    });
+    const customer = ((_a = result == null ? void 0 : result.data) == null ? void 0 : _a.customer) || (result == null ? void 0 : result.data) || (result == null ? void 0 : result.customer) || null;
+    return customer && typeof customer === "object" ? customer : null;
+  }
   /**
    * 获取客户列表
    * @param params 查询参数

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

@@ -112,6 +112,8 @@ export interface CustomerModuleAPI {
     getCustomerList: (params?: ShopGetCustomerListParams) => Promise<ICustomerListResponse>;
     /** 查询客户列表但不更新列表分页状态 */
     queryCustomerList: (params?: ShopGetCustomerListParams) => Promise<ICustomerListResponse>;
+    /** 查询单个客户详情但不修改客户列表状态 */
+    queryCustomerDetail: (id: string | number) => Promise<ShopCustomer | null>;
     /** 设置客户列表 */
     setCustomerList: (customers: ShopCustomer[], total?: number) => void;
     /** 设置当前选择的客户 */

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

@@ -25,9 +25,11 @@ export declare class DiscountModule extends BaseModule implements Module, Discou
         with_wallet_pass_holder: 0 | 1;
         with_available_wallet_flag?: 0 | 1;
         with_available_wallet_pass_flag?: 0 | 1;
+        with_virtual_currency?: 0 | 1;
         request_timezone: string;
         order_id?: number | string;
     }): Promise<DiscountPrepareConfigResult>;
+    private normalizeVirtualCurrencyList;
     batchSearch(code: string, options?: {
         customerId?: number;
         orderId?: number;