@pisell/pisellos 2.2.301 → 2.2.303

package/dist/solution/UnifiedBookingSales/types.d.ts

@@ -1,8 +1,12 @@
-import type { OpenDataConfig } from '../../modules/OpenData';
-import type { ProductListLoadProductsParams } from '../../modules/ProductList';
+import type { InvoiceLayoutConfig, InvoiceTemplateSettings, OpenDataConfig } from '../../modules/OpenData';
+import type { ProductListLoadProductsParams, ProductListStoreQueryParams } from '../../modules/ProductList';
+import type { ProductData } from '../../modules/Product/types';
 import type { LoadScheduleAvailableDateParams } from '../../modules/Schedule/types';
 import type { AvailabilityDateRange, AvailabilityErrorCode, AvailabilityId, AvailabilityOccupancy, AvailabilityProduct, AvailabilityProjection, AvailabilityQuery, AvailabilityRequirementSelection, AvailabilityResource, AvailabilitySelectionValidationResult, DateAvailabilityQueryResult, GetProductTimeRangesRequest, ProductAvailabilityQueryResult, ProductTimeRange, ProductTimeRangeGroup, ResourceAvailabilityGroup, ResourceAvailabilityRangeGroup, TimeAvailabilityGroup, TimeAvailabilityItem } from '../../modules/ResourcePlanner';
 import type { BookingTicketState } from '../BookingTicket/types';
+import type { AllergyRequirement } from '../../model/strategy/adapter/itemRule';
+import type { SalesNoteDraftInput } from '../../modules/Order/types';
+export type { ProductListStoreQueryParams } from '../../modules/ProductList';
 export type { AvailabilityAbsoluteRange, AvailabilityAssignment, AvailabilityCell, AvailabilityDateRange, AvailabilityDisplayRange, AvailabilityErrorCode, AvailabilityId, AvailabilityMode, AvailabilityOccupancy, AvailabilityProduct, AvailabilityProductKind, AvailabilityProjection, AvailabilityProjectionInput, AvailabilityProjectionMeta, AvailabilityQuery, AvailabilityQueryResult, AvailabilityRequirementGroup, AvailabilityRequirementGroupResult, AvailabilityRequirementSelection, AvailabilityResource, AvailabilityResourceOption, AvailabilityResourceType, AvailabilityResourceWindow, AvailabilityScheduleMode, AvailabilityScheduleRef, AvailabilityScheduleRule, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, AvailabilitySessionRange, AvailabilityStatus, DateAvailabilityGroup, DateAvailabilityItem, DateAvailabilityQuery, DateAvailabilityQueryResult, GetProductTimeRangesRequest, ProductAvailabilityGroup, ProductAvailabilityItem, ProductAvailabilityQuery, ProductAvailabilityQueryResult, ProductTimeRange, ProductTimeRangeGroup, QueryAvailabilityBaseRequest, ResourceAvailabilityGroup, ResourceAvailabilityQuery, ResourceAvailabilityQueryResult, ResourceAvailabilityRangeGroup, TimeAvailabilityGroup, TimeAvailabilityItem, TimeAvailabilityQuery, TimeAvailabilityQueryResult, } from '../../modules/ResourcePlanner';
 export interface UnifiedBookingSalesState extends BookingTicketState {
 }
@@ -24,6 +28,12 @@ export declare enum UnifiedBookingSalesHooks {
 export interface UnifiedBookingSalesOtherParams extends Record<string, any> {
     enableSessionStoragePersist?: boolean;
 }
+export type UnifiedBookingSalesAllergyRequirement = AllergyRequirement;
+export interface UnifiedBookingSalesResolveProductAllergyRequirementParams {
+    productId: number | string;
+    productVariantId?: number | string;
+    channel?: string;
+}
 export interface UnifiedBookingSalesLoadOpenDataParams {
     businessCode: string;
     channel: string;
@@ -151,6 +161,8 @@ export interface ContextualCommitAvailabilitySelectionParams {
     requirementSelections: AvailabilityRequirementSelection[];
     partySize: number;
     bookingCount?: number;
+    /** 新增商品行时与商品、预约在同一次 Order mutation 内写入的 Sales Notes。 */
+    salesNotes?: SalesNoteDraftInput[];
     /** 编辑预约时，允许本次显式报价覆盖已落库订单行的历史价格。 */
     allowBookingReprice?: boolean;
     /** 编辑预约重报价后，允许订单模块重新应用已选编辑态折扣。 */
@@ -205,9 +217,16 @@ export interface UnifiedBookingSalesDiscountResult {
 }
 export interface UnifiedBookingSalesApi {
     loadOpenData: (params: UnifiedBookingSalesLoadOpenDataParams) => Promise<OpenDataConfig>;
+    /** Returns the latest OpenData payload cached by this solution instance. */
     getOpenData: () => Promise<OpenDataConfig | null>;
+    /** Returns the normalized Documents Invoice layout for the active target. */
+    getInvoiceLayoutConfig: () => Promise<InvoiceLayoutConfig>;
+    /** Returns the Native Invoice template settings for the active target. */
+    getInvoiceTemplateSettings: () => Promise<InvoiceTemplateSettings>;
+    /** Date-first calendar availability backed by ScheduleModule. */
     loadScheduleAvailableDate: (params: LoadScheduleAvailableDateParams) => Promise<unknown>;
     loadProductsByScheduleDate: (params: UnifiedBookingSalesLoadProductsByScheduleDateParams) => Promise<unknown[]>;
+    queryProducts: (params?: ProductListStoreQueryParams) => Promise<ProductData[]>;
     stageRetailProducts: (params: UnifiedBookingSalesStageRetailProductsParams) => Promise<Record<string, any> | null>;
     addRetailProduct: (params: UnifiedBookingSalesAddRetailProductParams) => Promise<Record<string, any>[]>;
     prepareAvailabilityProjection: (params: UnifiedBookingSalesPrepareAvailabilityProjectionParams) => Promise<AvailabilityContextRef>;

package/dist/solution/VenueBooking/index.d.ts

@@ -15,6 +15,7 @@ interface VenueBookingItemRuleRuntimeConfig {
     pax?: Partial<PaxInfo>;
     historicalItems?: CartItemSummary[];
     serviceType?: string;
+    channel?: string;
     submissionIndex?: number;
     custom?: Record<string, any>;
 }

package/dist/solution/VenueBooking/index.js

@@ -3140,7 +3140,11 @@ export var VenueBookingImpl = /*#__PURE__*/function (_BaseSalesImpl) {
   }, {
     key: "getItemRuleRuntimeConfig",
     value: function getItemRuleRuntimeConfig() {
-      return this.itemRuleRuntimeConfig || {};
+      var _ref6, _runtimeConfig$channe, _runtimeConfig$custom, _this$otherParams21;
+      var runtimeConfig = this.itemRuleRuntimeConfig || {};
+      return _objectSpread(_objectSpread({}, runtimeConfig), {}, {
+        channel: (_ref6 = (_runtimeConfig$channe = runtimeConfig.channel) !== null && _runtimeConfig$channe !== void 0 ? _runtimeConfig$channe : (_runtimeConfig$custom = runtimeConfig.custom) === null || _runtimeConfig$custom === void 0 ? void 0 : _runtimeConfig$custom.channel) !== null && _ref6 !== void 0 ? _ref6 : (_this$otherParams21 = this.otherParams) === null || _this$otherParams21 === void 0 ? void 0 : _this$otherParams21.channel
+      });
     }
   }, {
     key: "ensureItemRuleConfigsLoaded",
@@ -3806,14 +3810,14 @@ export var VenueBookingImpl = /*#__PURE__*/function (_BaseSalesImpl) {
     key: "setOtherParams",
     value: function () {
       var _setOtherParams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee46(params) {
-        var _ref7,
-          _ref7$cover,
+        var _ref8,
+          _ref8$cover,
           cover,
           _args46 = arguments;
         return _regeneratorRuntime().wrap(function _callee46$(_context46) {
           while (1) switch (_context46.prev = _context46.next) {
             case 0:
-              _ref7 = _args46.length > 1 && _args46[1] !== undefined ? _args46[1] : {}, _ref7$cover = _ref7.cover, cover = _ref7$cover === void 0 ? false : _ref7$cover;
+              _ref8 = _args46.length > 1 && _args46[1] !== undefined ? _args46[1] : {}, _ref8$cover = _ref8.cover, cover = _ref8$cover === void 0 ? false : _ref8$cover;
               if (cover) {
                 this.otherParams = params;
               } else {

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

@@ -10,7 +10,7 @@ var _adapter = require("./adapter");
 /**
  * Data Variant 评估器。
  *
- * 当前阶段只提供策略模型能力和示例验证，不接入 ProductList 业务链路。
+ * OS Server 商品路由开启时由 ProductsModule 调用；路由关闭时由 ProductList 在远端响应后调用。
  */
 class DataVariantEvaluator {
   adapter;
@@ -32,16 +32,22 @@ class DataVariantEvaluator {
   /**
    * 批量解析商品 Data Variant。
    *
-   * 先执行全局预计算，再只针对商品自身 data_variants 引用到的规则做商品级判断。
+   * 优先使用商品 metadata.data_variant_ids；缺少权威命中结果时才执行本地策略判断。
    */
   resolveProducts(businessData) {
     const strategyConfigs = businessData.strategyConfigs ? this.normalizeStrategyConfigs(businessData.strategyConfigs) : this.strategyConfigs;
     const menuScopeMap = this.buildMenuScopeMap(businessData.menuList || []);
     const scheduleTimePoints = this.buildScheduleTimePoints(strategyConfigs, businessData.scheduleList || []);
+    // metadata.data_variant_ids 存在时，接口已经完成规则计算；只有仍有商品缺少
+    // 该权威结果时才初始化本地策略引擎，避免 OS/接口与客户端重复评估。
+    const shouldEvaluateStrategies = businessData.products.some(product => this.requiresLocalStrategyEvaluation(product));
     const {
       globalEffectiveRuleMap,
       rawResults
-    } = this.buildGlobalEffectiveRuleMap(strategyConfigs, businessData, menuScopeMap);
+    } = shouldEvaluateStrategies ? this.buildGlobalEffectiveRuleMap(strategyConfigs, businessData, menuScopeMap) : {
+      globalEffectiveRuleMap: new Map(),
+      rawResults: []
+    };
     const products = businessData.products.map(product => {
       const resolvedProduct = this.resolveProduct(product, businessData, globalEffectiveRuleMap, menuScopeMap);
       // 套餐子商品也可能携带 data_variants，需在同一策略上下文内继续评估并写回 bundle_item。
@@ -124,6 +130,46 @@ class DataVariantEvaluator {
     const matchedSchedules = scheduleList.filter(schedule => scheduleIdSet.has(Number(schedule.id)));
     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?.bundle_item) ? group.bundle_item : [];
+      return bundleItems.some(item => this.requiresLocalStrategyEvaluation(this.toBundleItemDataVariantProduct(item)));
+    });
+  }
+
+  /**
+   * 将接口返回的高 -> 低优先级 Variant ID 转成数值优先级。
+   * 返回 null 表示接口没有提供该字段；空 Map 表示已计算但没有任何命中。
+   */
+  getAuthoritativeVariantPriorities(product) {
+    const rawIds = product?.metadata?.data_variant_ids;
+    if (!Array.isArray(rawIds)) return null;
+    const orderedIds = [];
+    const seen = 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 === undefined || value === null) return null;
+    const normalized = String(value).trim();
+    return normalized || null;
+  }
   buildGlobalEffectiveRuleMap(strategyConfigs, businessData, menuScopeMap) {
     const globalEffectiveRuleMap = new Map();
     const rawResults = [];
@@ -155,7 +201,22 @@ class DataVariantEvaluator {
     const dataVariants = this.getProductDataVariants(product);
     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 ? undefined : authoritativeVariantPriorities.get(variantId);
+        if (priority === undefined) 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));
       if (!rule) continue;
       if (!this.evaluateProductRules(rule, product, businessData, menuScopeMap)) {
@@ -168,8 +229,76 @@ class DataVariantEvaluator {
         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 => {
+      const settlement = variant.data?.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 ? undefined : globalEffectiveRuleMap.get(ruleId);
+      const variantId = this.normalizeDataVariantId(variant.id);
+      const authoritativePriority = variantId === null ? undefined : authoritativeVariantPriorities?.get(variantId);
+      let available;
+      let priority;
+      if (isDefault) {
+        // rule 0 是无条件默认候选，不依赖接口命中 ID 或本地策略引擎。
+        available = true;
+        priority = Number.NEGATIVE_INFINITY;
+      } else if (authoritativeVariantPriorities !== null) {
+        // 数组存在（包括 []）即表示接口已经算过规则，不再在客户端二次判断。
+        available = authoritativePriority !== undefined;
+        priority = authoritativePriority ?? rule?.priority ?? Number.NEGATIVE_INFINITY;
+      } else {
+        available = Boolean(rule && this.evaluateProductRules(rule, product, businessData, menuScopeMap));
+        priority = 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(variant.data?.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 = 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;
+    });
   }
 
   /**
@@ -222,7 +351,8 @@ class DataVariantEvaluator {
       product_variant_id: variantId,
       variant_id: variantId,
       collection: item.collection,
-      data_variants: item.data_variants
+      data_variants: item.data_variants,
+      metadata: item.metadata
     };
   }
 
@@ -453,6 +583,7 @@ class DataVariantEvaluator {
     }
     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/itemRule/adapter.d.ts

@@ -1,6 +1,6 @@
 import type { EvaluationResult, RuntimeContext, ActionEffect } from '../../type';
 import type { BusinessAdapter } from '../type';
-import { type ItemRuleBusinessData, type QuantityCheckResult, type PrefillItemResult, type QuantityLimitResult } from './type';
+import { type ItemRuleBusinessData, type QuantityCheckResult, type PrefillItemResult, type QuantityLimitResult, type AllergyRequirement } from './type';
 /**
  * ItemRule 适配器
  *
@@ -14,7 +14,10 @@ export declare class ItemRuleAdapter implements BusinessAdapter {
     transformResult(result: EvaluationResult, businessData?: ItemRuleBusinessData): {
         quantityChecks: QuantityCheckResult[];
         prefillItems: PrefillItemResult[];
+        allergyRequirements: AllergyRequirement[];
     };
+    private processAllergyCheck;
+    private normalizeAllergyDataSourceItems;
     formatConfig(result: EvaluationResult, businessData?: ItemRuleBusinessData): {
         result: EvaluationResult;
         businessData?: ItemRuleBusinessData;

package/lib/model/strategy/adapter/itemRule/adapter.js

@@ -19,14 +19,17 @@ class ItemRuleAdapter {
       pax,
       cartItems,
       serviceType,
+      channel,
       submissionIndex,
       custom
     } = businessData;
+    const resolvedChannel = String(channel ?? custom?.channel ?? '').trim();
     return {
       entities: {
         cartItems,
         historicalItems: businessData.historicalItems || [],
-        pax
+        pax,
+        currentProduct: businessData.currentProduct
       },
       attributes: {
         serviceType: serviceType || '',
@@ -36,7 +39,8 @@ class ItemRuleAdapter {
         submissionIndex: submissionIndex ?? 0,
         cartItemCount: cartItems.length,
         cartTotalQuantity: cartItems.reduce((sum, item) => sum + item.quantity, 0),
-        ...custom
+        ...custom,
+        channel: resolvedChannel
       },
       metadata: {
         timestamp: Date.now()
@@ -46,10 +50,12 @@ class ItemRuleAdapter {
   transformResult(result, businessData) {
     const quantityChecks = [];
     const prefillItems = [];
+    const allergyRequirements = [];
     if (!result.applicable || !businessData) {
       return {
         quantityChecks,
-        prefillItems
+        prefillItems,
+        allergyRequirements
       };
     }
     for (const action of result.matchedActions) {
@@ -61,13 +67,76 @@ class ItemRuleAdapter {
       } else if (action.type === _type.ITEM_RULE_ACTION_TYPES.PREFILL_CART) {
         const items = this.processPrefillCart(action, businessData);
         prefillItems.push(...items);
+      } else if (action.type === _type.ITEM_RULE_ACTION_TYPES.ALLERGY_CHECK) {
+        const requirement = this.processAllergyCheck(action, result, businessData);
+        if (requirement) allergyRequirements.push(requirement);
       }
     }
     return {
       quantityChecks,
-      prefillItems
+      prefillItems,
+      allergyRequirements
     };
   }
+
+  // ============================================
+  // Allergy Check 处理
+  // ============================================
+
+  processAllergyCheck(action, result, businessData) {
+    const config = action.config;
+    const currentProduct = businessData.currentProduct;
+    if (!config || config.targetType !== 'product' || config.promptScope !== 'once_per_order_product' || !Array.isArray(config.targets) || !currentProduct) {
+      return null;
+    }
+    const currentProductId = Number(currentProduct.product_id);
+    const currentVariantId = Number(currentProduct.product_variant_id ?? 0);
+    if (!Number.isFinite(currentProductId) || currentProductId <= 0) return null;
+    const productTargets = config.targets.filter(item => Number(item.product_id) === currentProductId);
+    const target = productTargets.find(item => currentVariantId > 0 && Number(item.product_variant_id ?? 0) === currentVariantId) ?? productTargets.find(item => Number(item.product_variant_id ?? 0) <= 0);
+    if (!target || target.dataSource?.type !== 'inline') return null;
+    const items = this.normalizeAllergyDataSourceItems(target.dataSource.items);
+    if (!items.length) return null;
+    return {
+      strategyId: result.config.metadata.id,
+      ruleId: action.id,
+      priority: action.priority ?? 0,
+      targetType: 'product',
+      product_id: currentProductId,
+      ...(Number(target.product_variant_id ?? 0) > 0 ? {
+        product_variant_id: Number(target.product_variant_id)
+      } : {}),
+      dataSource: {
+        type: 'inline',
+        items
+      },
+      promptScope: config.promptScope,
+      allowNote: config.allowNote === true
+    };
+  }
+  normalizeAllergyDataSourceItems(items) {
+    if (!Array.isArray(items)) return [];
+    const uniqueIds = new Set();
+    const normalized = [];
+    for (const item of items) {
+      const id = String(item?.id ?? '').trim();
+      const rawLabel = item?.label;
+      const label = typeof rawLabel === 'string' ? rawLabel.trim() : Object.entries(rawLabel || {}).reduce((labels, [locale, value]) => {
+        if (typeof value === 'string' && value.trim().length > 0) {
+          labels[locale] = value.trim();
+        }
+        return labels;
+      }, {});
+      const hasLabel = typeof label === 'string' ? label.length > 0 : Object.keys(label).length > 0;
+      if (!id || !hasLabel || uniqueIds.has(id)) continue;
+      uniqueIds.add(id);
+      normalized.push({
+        id,
+        label
+      });
+    }
+    return normalized;
+  }
   formatConfig(result, businessData) {
     return {
       result,

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

@@ -1,5 +1,5 @@
 import type { StrategyConfig } from '../../type';
-import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult } from './type';
+import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult, type AllergyRequirement } from './type';
 /**
  * ItemRule 评估器
  *
@@ -21,6 +21,13 @@ export declare class ItemRuleEvaluator {
      * 完整评估：数量校验 + 预填购物车
      */
     evaluate(businessData: ItemRuleBusinessData): ItemRuleEvaluationResult;
+    /**
+     * 获取当前商品优先级最高的过敏门禁要求。
+     *
+     * 不同商品或不同 Action 的数据源不会合并；相同优先级按
+     * strategyId + ruleId 稳定排序，保证多次评估结果一致。
+     */
+    getAllergyRequirement(businessData: ItemRuleBusinessData): AllergyRequirement | null;
     /**
      * 获取当前配置中各商品的数量限制
      *

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

@@ -43,6 +43,7 @@ class ItemRuleEvaluator {
     const configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter(c => c.metadata.type === 'item_rule') : this.strategyConfigs;
     const allQuantityChecks = [];
     const allPrefillItems = [];
+    const allAllergyRequirements = [];
     const rawResults = [];
     const context = this.adapter.prepareContext(businessData);
     for (const config of configs) {
@@ -50,21 +51,42 @@ class ItemRuleEvaluator {
       rawResults.push(evalResult);
       const {
         quantityChecks,
-        prefillItems
+        prefillItems,
+        allergyRequirements
       } = this.adapter.transformResult(evalResult, businessData);
       allQuantityChecks.push(...quantityChecks);
       allPrefillItems.push(...prefillItems);
+      allAllergyRequirements.push(...allergyRequirements);
     }
     const failedChecks = allQuantityChecks.filter(c => !c.passed);
     return {
       quantityChecks: allQuantityChecks,
       prefillItems: allPrefillItems,
+      allergyRequirements: allAllergyRequirements,
       allPassed: failedChecks.length === 0,
       failedChecks,
       rawResults
     };
   }
 
+  /**
+   * 获取当前商品优先级最高的过敏门禁要求。
+   *
+   * 不同商品或不同 Action 的数据源不会合并；相同优先级按
+   * strategyId + ruleId 稳定排序，保证多次评估结果一致。
+   */
+  getAllergyRequirement(businessData) {
+    const requirements = this.evaluate(businessData).allergyRequirements;
+    if (!requirements.length) return null;
+    return [...requirements].sort((left, right) => {
+      const priorityDiff = right.priority - left.priority;
+      if (priorityDiff !== 0) return priorityDiff;
+      const strategyDiff = left.strategyId.localeCompare(right.strategyId);
+      if (strategyDiff !== 0) return strategyDiff;
+      return left.ruleId.localeCompare(right.ruleId);
+    })[0];
+  }
+
   /**
    * 获取当前配置中各商品的数量限制
    *