@pisell/pisellos 0.0.499 → 0.0.501

package/dist/model/strategy/adapter/itemRule/adapter.d.ts

@@ -50,6 +50,14 @@ export declare class ItemRuleAdapter implements BusinessAdapter {
      * 不适用或无配置时返回 null。
      */
     extractQuantityLimits(action: ActionEffect, businessData: ItemRuleBusinessData): QuantityLimitResult | null;
+    /**
+     * 计算当前提交剩余可选的最大数量。
+     *
+     * 仅在 scope='cumulative' 且存在 requiredMax 时生效：
+     * 用 requiredMax 减去 historicalItems 中目标商品的累计数量，保底 0。
+     * 其余场景返回 undefined，保持向后兼容。
+     */
+    private calculateRemainingMax;
     private processPrefillCart;
     /**
      * 根据 quantityFrom 计算预填数量

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

@@ -327,7 +327,8 @@ export var ItemRuleAdapter = /*#__PURE__*/function () {
       var scope = config.scope,
         quantityRules = config.quantityRules,
         targetType = config.targetType,
-        targets = config.targets;
+        targets = config.targets,
+        validationMessage = config.validationMessage;
       if (!this.shouldEvaluateForScope(scope, (_businessData$submiss2 = businessData.submissionIndex) !== null && _businessData$submiss2 !== void 0 ? _businessData$submiss2 : 0)) {
         return null;
       }
@@ -373,18 +374,61 @@ export var ItemRuleAdapter = /*#__PURE__*/function () {
       } finally {
         _iterator4.f();
       }
+      var remainingMax = this.calculateRemainingMax(scope, requiredMax, targets, businessData);
+      var formattedValidationMessage = this.formatValidationMessage(validationMessage, requiredMin, requiredMax, requiredExact);
       return {
         ruleId: action.id,
         targetType: targetType,
         targets: targets,
         requiredMin: requiredMin,
         requiredMax: requiredMax,
+        remainingMax: remainingMax,
         requiredExact: requiredExact,
         mustInclude: mustInclude,
-        scope: scope
+        scope: scope,
+        validationMessage: formattedValidationMessage,
+        rawValidationMessage: validationMessage
       };
     }
 
+    /**
+     * 计算当前提交剩余可选的最大数量。
+     *
+     * 仅在 scope='cumulative' 且存在 requiredMax 时生效：
+     * 用 requiredMax 减去 historicalItems 中目标商品的累计数量，保底 0。
+     * 其余场景返回 undefined，保持向后兼容。
+     */
+  }, {
+    key: "calculateRemainingMax",
+    value: function calculateRemainingMax(scope, requiredMax, targets, businessData) {
+      if (scope !== 'cumulative' || typeof requiredMax !== 'number') {
+        return undefined;
+      }
+      var historicalItems = businessData.historicalItems;
+      if (!(historicalItems !== null && historicalItems !== void 0 && historicalItems.length)) {
+        return Math.max(0, requiredMax);
+      }
+      var targetIds = new Set(targets.map(function (t) {
+        return t.product_id;
+      }));
+      var historicalQty = 0;
+      var _iterator5 = _createForOfIteratorHelper(historicalItems),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var item = _step5.value;
+          if (targetIds.has(item.product_id)) {
+            historicalQty += item.quantity;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return Math.max(0, requiredMax - historicalQty);
+    }
+
     // ============================================
     // Prefill Cart 处理
     // ============================================
@@ -394,11 +438,11 @@ export var ItemRuleAdapter = /*#__PURE__*/function () {
       var config = action.config;
       if (!(config !== null && config !== void 0 && config.products)) return [];
       var results = [];
-      var _iterator5 = _createForOfIteratorHelper(config.products),
-        _step5;
+      var _iterator6 = _createForOfIteratorHelper(config.products),
+        _step6;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var prefillProduct = _step5.value;
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var prefillProduct = _step6.value;
           var quantity = this.resolvePrefillQuantity(prefillProduct.quantityFrom, prefillProduct.quantity, businessData);
           if (quantity <= 0) continue;
           results.push({
@@ -409,9 +453,9 @@ export var ItemRuleAdapter = /*#__PURE__*/function () {
           });
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
       return results;
     }

package/dist/model/strategy/adapter/itemRule/examples.d.ts

@@ -25,6 +25,21 @@ export declare const MAX_BUNS_PER_TABLE_STRATEGY: StrategyConfig;
  *   - Prefill Cart: 自动添加默认锅底 x 1
  */
 export declare const HOTPOT_BASE_REQUIRED_STRATEGY: StrategyConfig;
+/**
+ * 场景：4 款锅底里任选至少 1 款，不自动预填，不限制多选上限
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 4 个锅底商品合计数量 >= 1 （OR 组语义）
+ *
+ * 说明：
+ *   - targets 里放多个 product_id 时，ItemRuleAdapter 会把它们视为 OR 组，
+ *     仅校验「合计数量」，不会要求每款各自满足 min。
+ *   - ScanOrder 工具层 buildQuantityLimitIndex 会跳过多目标规则的
+ *     单品索引，避免 UI 把组级 min 误当作每张商品卡的减号下限，
+ *     锁死用户切换锅底的操作。
+ */
+export declare const HOTPOT_BASE_PICK_ONE_STRATEGY: StrategyConfig;
 /**
  * ItemRuleEvaluator 简洁调用示例
  *

package/dist/model/strategy/adapter/itemRule/examples.js

@@ -205,7 +205,74 @@ export var HOTPOT_BASE_REQUIRED_STRATEGY = {
 };
 
 // ============================================
-// 示例 4：ItemRuleEvaluator 用法（简洁调用 + 完整 Demo）
+// 示例 4：锅底四选一（Multi-target OR 组至少 1 份）
+// ============================================
+
+/**
+ * 场景：4 款锅底里任选至少 1 款，不自动预填，不限制多选上限
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 4 个锅底商品合计数量 >= 1 （OR 组语义）
+ *
+ * 说明：
+ *   - targets 里放多个 product_id 时，ItemRuleAdapter 会把它们视为 OR 组，
+ *     仅校验「合计数量」，不会要求每款各自满足 min。
+ *   - ScanOrder 工具层 buildQuantityLimitIndex 会跳过多目标规则的
+ *     单品索引，避免 UI 把组级 min 误当作每张商品卡的减号下限，
+ *     锁死用户切换锅底的操作。
+ */
+export var HOTPOT_BASE_PICK_ONE_STRATEGY = {
+  metadata: {
+    id: 'RULE_HOTPOT_BASE_PICK_ONE',
+    name: {
+      'zh-CN': '锅底必选（四选一）',
+      en: 'Hotpot base required (pick any)'
+    },
+    type: 'item_rule',
+    description: {
+      'zh-CN': '4 款锅底任选至少 1 份',
+      en: 'Pick at least 1 hotpot base from the available options'
+    }
+  },
+  conditions: {
+    operator: 'and',
+    rules: [],
+    actionIds: ['quantity_check_hotpot_base_group']
+  },
+  actions: [{
+    id: 'quantity_check_hotpot_base_group',
+    type: ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK,
+    value: null,
+    target: 'cart',
+    priority: 10,
+    config: {
+      targetType: 'product',
+      targets: [{
+        product_id: 30001
+      }, {
+        product_id: 30002
+      }, {
+        product_id: 30003
+      }, {
+        product_id: 30004
+      }],
+      quantityRules: [{
+        comparison: 'minimum',
+        source: 'fixed',
+        value: 1
+      }],
+      scope: 'first_submission_only',
+      validationMessage: {
+        'zh-CN': '请至少选择 {min} 款锅底',
+        en: 'Please select at least {min} hotpot base'
+      }
+    }
+  }]
+};
+
+// ============================================
+// 示例 5：ItemRuleEvaluator 用法（简洁调用 + 完整 Demo）
 // ============================================
 
 /**

package/dist/model/strategy/adapter/itemRule/index.d.ts

@@ -1,5 +1,5 @@
 export { ItemRuleEvaluator } from './evaluator';
 export { ItemRuleAdapter } from './adapter';
 export { default } from './adapter';
-export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo, } from './examples';
+export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, HOTPOT_BASE_PICK_ONE_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo, } from './examples';
 export * from './type';

package/dist/model/strategy/adapter/itemRule/index.js

@@ -1,5 +1,5 @@
 export { ItemRuleEvaluator } from "./evaluator";
 export { ItemRuleAdapter } from "./adapter";
 export { default } from "./adapter";
-export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo } from "./examples";
+export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, HOTPOT_BASE_PICK_ONE_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo } from "./examples";
 export * from "./type";

package/dist/model/strategy/adapter/itemRule/type.d.ts

@@ -180,14 +180,33 @@ export interface QuantityLimitResult {
     targets: TargetItem[];
     /** 要求的最小数量 */
     requiredMin?: number;
-    /** 要求的最大数量 */
+    /** 要求的最大数量（规则配置的原始上限，用于 UI 文案展示） */
     requiredMax?: number;
+    /**
+     * 当前提交剩余可选的最大数量。
+     *
+     * 仅在 scope='cumulative' 且存在 requiredMax 时计算：
+     *   remainingMax = max(0, requiredMax - historicalItems 中目标商品累计数量)
+     *
+     * 非 cumulative 场景不设置此字段；调用方用于限制加购上限时，
+     * 应优先读取本字段，未定义时回退到 requiredMax。
+     */
+    remainingMax?: number;
     /** 要求的精确数量 */
     requiredExact?: number;
     /** 是否必须包含 */
     mustInclude?: boolean;
     /** 作用范围 */
     scope: RuleScope;
+    /**
+     * 校验失败时的提示语（已做 {min}/{max}/{exact} 占位符替换）。
+     * 当 rawValidationMessage 为多语言对象时，后端不做 locale 选择，
+     * 默认按 en → Object.values()[0] 的顺序兜底，前端可再根据自身 locale
+     * 读取 rawValidationMessage 做精确匹配。
+     */
+    validationMessage?: string;
+    /** 原始多语言模板，前端可根据自身 locale 做二次选择 */
+    rawValidationMessage?: string | Record<string, string>;
 }
 /**
  * ItemRule 评估器的完整输出结果

package/dist/model/strategy/adapter/promotion/index.js

@@ -0,0 +1,9 @@
+// 导出评估器
+export { PromotionEvaluator } from "./evaluator";
+
+// 导出适配器
+export { PromotionAdapter } from "./adapter";
+export { default } from "./adapter";
+
+// 导出策略配置示例常量
+export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY } from "./examples";

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

@@ -76,6 +76,10 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     removeProductFromOrder(identity: ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
     submitTempOrder<T = any>(params?: {
         cacheId?: string;
+        platform?: string;
+        businessCode?: string;
+        channel?: string;
+        type?: string;
     }): Promise<T>;
     createOrder(params: CommitOrderParams['query']): {
         type: "virtual" | "appointment_booking";
@@ -108,4 +112,6 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     createOrderByCheckout(params: CheckoutOrderParams): Promise<any>;
     submitScanOrder<T = any>(params: SubmitScanOrderParams): Promise<T>;
     scanOrderMore<T = any>(params: ScanOrderMoreParams): Promise<T>;
+    getOrderInfoByRemote(order_id: number): Promise<any>;
+    getLastOrderInfo(): Record<string, any> | undefined;
 }

package/dist/modules/Order/index.js

@@ -25,7 +25,7 @@ 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 { generateDuration, getAllDiscountList, mergeRelationForms, buildSubmitPayload, createDefaultTempOrder, createEmptySummary, formatDateTime, formatV1Product, isTempOrder } from "./utils";
+import { generateDuration, getAllDiscountList, mergeRelationForms, buildSubmitPayload, createDefaultTempOrder, createDefaultOrderRulesHooks, createEmptySummary, formatDateTime, formatV1Product, isTempOrder } from "./utils";
 import { isNormalProduct } from "../Product/utils";
 import dayjs from 'dayjs';
 import { getProductIdentityIndex, getSafeProductNum, isIdentityMatch, normalizeOrderProduct } from "../../solution/ScanOrder/utils";
@@ -141,10 +141,26 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "registerDiscountModules",
     value: function registerDiscountModules(options) {
+      var _targetCacheData;
+      var targetCacheData = {};
+      if (this.cacheId && this.window) {
+        var sessionData = this.window.sessionStorage.getItem(this.name);
+        if (sessionData) {
+          try {
+            var data = JSON.parse(sessionData);
+            targetCacheData = (data === null || data === void 0 ? void 0 : data[this.cacheId]) || {};
+          } catch (_unused) {
+            // sessionStorage 损坏则忽略，按空 initialState 走
+          }
+        }
+      }
       var discount = new DiscountModule("".concat(this.name, "_discount"));
       this.core.registerModule(discount, {
+        initialState: (_targetCacheData = targetCacheData) === null || _targetCacheData === void 0 ? void 0 : _targetCacheData[discount.name],
         otherParams: {
-          fatherModule: this.name
+          fatherModule: this.name,
+          openCache: !!this.cacheId,
+          cacheId: this.cacheId
         }
       });
       this.store.discount = discount;
@@ -157,42 +173,7 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "createDefaultRulesHooks",
     value: function createDefaultRulesHooks() {
-      return {
-        getProduct: function getProduct(product) {
-          var _product$_origin, _product$_origin2, _product$_origin3, _product$_origin4;
-          return {
-            id: product.product_id,
-            _id: product.identity_key ? "".concat(product.product_id, "_").concat(product.product_variant_id, "_").concat(product.identity_key) : "".concat(product.product_id, "_").concat(product.product_variant_id),
-            price: product.selling_price,
-            total: new Decimal(product.payment_price || product.selling_price || 0).times(product.num || 1).toNumber(),
-            origin_total: new Decimal(product.original_price || product.selling_price || 0).times(product.num || 1).toNumber(),
-            original_price: product.original_price,
-            quantity: product.num || 1,
-            num: product.num || 1,
-            discount_list: product.discount_list || [],
-            bundle: product.product_bundle || [],
-            booking_id: ((_product$_origin = product._origin) === null || _product$_origin === void 0 ? void 0 : _product$_origin.booking_id) || null,
-            isClient: false,
-            isManualDiscount: ((_product$_origin2 = product._origin) === null || _product$_origin2 === void 0 ? void 0 : _product$_origin2.isManualDiscount) || false,
-            holder_id: (_product$_origin3 = product._origin) === null || _product$_origin3 === void 0 ? void 0 : _product$_origin3.holder_id,
-            startDate: (_product$_origin4 = product._origin) === null || _product$_origin4 === void 0 ? void 0 : _product$_origin4.startDate
-          };
-        },
-        setProduct: function setProduct(product, values) {
-          var _values$discount_list, _values$quantity, _values$bundle;
-          return _objectSpread(_objectSpread({}, product), {}, {
-            selling_price: values.price !== undefined ? String(values.price) : product.selling_price,
-            payment_price: values.total !== undefined ? String(values.total) : product.payment_price,
-            original_price: values.original_price !== undefined ? String(values.original_price) : product.original_price,
-            discount_list: (_values$discount_list = values.discount_list) !== null && _values$discount_list !== void 0 ? _values$discount_list : product.discount_list,
-            num: (_values$quantity = values.quantity) !== null && _values$quantity !== void 0 ? _values$quantity : product.num,
-            product_bundle: (_values$bundle = values.bundle) !== null && _values$bundle !== void 0 ? _values$bundle : product.product_bundle,
-            metadata: _objectSpread(_objectSpread({}, product.metadata || {}), values.main_product_selling_price !== undefined ? {
-              main_product_selling_price: String(values.main_product_selling_price)
-            } : {})
-          });
-        }
-      };
+      return createDefaultOrderRulesHooks();
     }
 
     // ─── Discount: 公共 API ───
@@ -404,7 +385,7 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
           return;
         }
         this.store.tempOrder = parsedData;
-      } catch (_unused) {
+      } catch (_unused2) {
         var _this$window;
         (_this$window = this.window) === null || _this$window === void 0 || (_this$window = _this$window.localStorage) === null || _this$window === void 0 || _this$window.removeItem(key);
       }
@@ -726,7 +707,11 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
               effectiveCacheId = (_params$cacheId = params === null || params === void 0 ? void 0 : params.cacheId) !== null && _params$cacheId !== void 0 ? _params$cacheId : this.cacheId;
               payload = buildSubmitPayload({
                 tempOrder: tempOrder,
-                cacheId: effectiveCacheId
+                cacheId: effectiveCacheId,
+                platform: params === null || params === void 0 ? void 0 : params.platform,
+                businessCode: params === null || params === void 0 ? void 0 : params.businessCode,
+                channel: params === null || params === void 0 ? void 0 : params.channel,
+                type: params === null || params === void 0 ? void 0 : params.type
               });
               if (!tempOrder.order_id) {
                 _context10.next = 12;
@@ -1085,7 +1070,42 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
         return _scanOrderMore.apply(this, arguments);
       }
       return scanOrderMore;
+    }() // TODO 获取详情的接口
+  }, {
+    key: "getOrderInfoByRemote",
+    value: function () {
+      var _getOrderInfoByRemote = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(order_id) {
+        var res;
+        return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _context15.next = 2;
+              return this.request.get("/order/sales/".concat(order_id), {
+                with: ['products', 'scheduleEvents']
+              });
+            case 2:
+              res = _context15.sent;
+              if (res.code === 200 && this.store.tempOrder) {
+                this.store.tempOrder.lastOrderInfo = res.data;
+              }
+              return _context15.abrupt("return", res);
+            case 5:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function getOrderInfoByRemote(_x15) {
+        return _getOrderInfoByRemote.apply(this, arguments);
+      }
+      return getOrderInfoByRemote;
     }()
+  }, {
+    key: "getLastOrderInfo",
+    value: function getLastOrderInfo() {
+      var _this$store;
+      return (_this$store = this.store) === null || _this$store === void 0 || (_this$store = _this$store.tempOrder) === null || _this$store === void 0 ? void 0 : _this$store.lastOrderInfo;
+    }
   }], [{
     key: "populateSavedAmounts",
     value:

package/dist/modules/Order/types.d.ts

@@ -212,6 +212,10 @@ export interface OrderModuleAPI {
     persistTempOrder: () => void;
     submitTempOrder: <T = any>(params?: {
         cacheId?: string;
+        platform?: string;
+        businessCode?: string;
+        channel?: string;
+        type?: string;
     }) => Promise<T>;
     loadDiscountConfig: (params: {
         customerId: number;

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

@@ -1,5 +1,25 @@
 import { CartItem } from "../Cart";
 import type { ScanOrderSubmitPayload, ScanOrderSubmitProduct, ScanOrderSummary, ScanOrderTempOrder } from '../../solution/ScanOrder/types';
+import type { RulesParamsHooks } from '../Rules/types';
+/**
+ * OrderModule 默认 Rules 钩子工厂。
+ *
+ * 价格语义约定（订单域）：
+ * - `selling_price`：券后单品单价（实际成交单价）。初次加购 = `original_price`；券应用后由 Rules 引擎更新。
+ * - `original_price`：券前单品单价（店铺售价）。不承载后台划线价语义。
+ * - `payment_price`：已从内部字段移除；只在出站 payload 中由 `selling_price` 派生以兼容后端。
+ *
+ * Rules 钩子契约：
+ * - `getProduct.total` = `selling_price × num`（当前成交总价）
+ * - `getProduct.origin_total` = `original_price × num`（券前总价）
+ * - `setProduct` 写回 `selling_price` 的优先级：
+ *   1. `values.main_product_selling_price`（券应用分支，per-unit 券后主价）
+ *   2. `values.price`（还原分支 `restoredPrice`、good_pass 归零）
+ *   3. `values.total / num`（仅当 Rules 只给出总价时的兜底）
+ *
+ * 导出为纯函数方便单测直接驱动钩子，不依赖 OrderModule 实例。
+ */
+export declare function createDefaultOrderRulesHooks(): RulesParamsHooks;
 /**
  * 通过 session 类商品的开始时间结束时间生成商品的时长
  * @param {CartItem} cartItem
@@ -25,6 +45,13 @@ export declare const getAllDiscountList: (cartItem: CartItem) => any;
 export declare function createUuidV4(): string;
 export declare function isTempOrder(data: any): data is ScanOrderTempOrder;
 export declare function formatDateTime(date: Date): string;
+export declare function normalizeSubmitBooking<T extends {
+    metadata?: Record<string, any>;
+}>(booking: T): T;
+/** 提交用人数：有限且为正则向下取整，否则为 1 */
+export declare function normalizeSubmitCollectPaxValue(value: unknown): number;
+/** 从临时订单 metadata 解析合成 booking 的 collect_pax */
+export declare function resolveSubmitCollectPax(tempOrder: ScanOrderTempOrder): number;
 export declare function createDefaultTempOrder(params: {
     now: string;
     summary?: ScanOrderSummary;
@@ -33,6 +60,10 @@ export declare function buildSubmitPayload(params: {
     tempOrder: ScanOrderTempOrder;
     cacheId?: string;
     now?: Date;
+    platform?: string;
+    businessCode?: string;
+    channel?: string;
+    type?: string;
 }): ScanOrderSubmitPayload;
 export declare function formatV1Product(products: ScanOrderSubmitProduct[]): {
     bundle: any[];