@pisell/pisellos 2.1.129 → 2.1.131

package/dist/solution/ScanOrder/utils.js

@@ -11,6 +11,10 @@ function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" ==
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import dayjs from 'dayjs';
+import Decimal from 'decimal.js';
+import { composeLinePrice, createUuidV4, sumOptionUnitPrice } from "../../modules/Order/utils";
+
 /**
  * 构建金额全为 0 的空 summary。
  * 作为尚未计算金额时的兜底默认值，避免下游因 undefined 报错。
@@ -366,14 +370,75 @@ export function attachItemRuleLimitsToTopLevelProducts(productList, limits) {
 }
 
 /**
- * 判断两个商品 identity 是否匹配。
- * 当双方都没有 identity_key 时回退到 product_id + product_variant_id 比较（向后兼容）；
- * 一旦有一方携带 identity_key，则必须严格相等。
+ * 将选项行 / 套餐行归一成稳定 JSON，用于「同 SKU 是否合并」判断。
+ * 数组元素先按主键排序再序列化，避免顺序差异导致误判为不同行。
+ */
+export function buildProductLineFingerprint(productOptionItem, productBundle) {
+  var optArr = Array.isArray(productOptionItem) ? productOptionItem : [];
+  var normalizedOpts = optArr.map(function (item) {
+    var _item$price;
+    return {
+      product_option_item_id: Number(item === null || item === void 0 ? void 0 : item.product_option_item_id) || 0,
+      option_group_id: Number(item === null || item === void 0 ? void 0 : item.option_group_id) || 0,
+      num: typeof (item === null || item === void 0 ? void 0 : item.num) === 'number' && !Number.isNaN(item.num) ? Math.max(1, Math.floor(item.num)) : 1,
+      price: String((_item$price = item === null || item === void 0 ? void 0 : item.price) !== null && _item$price !== void 0 ? _item$price : '')
+    };
+  }).sort(function (p, q) {
+    if (p.product_option_item_id !== q.product_option_item_id) {
+      return p.product_option_item_id - q.product_option_item_id;
+    }
+    if (p.option_group_id !== q.option_group_id) return p.option_group_id - q.option_group_id;
+    if (p.num !== q.num) return p.num - q.num;
+    return p.price.localeCompare(q.price);
+  });
+  var bundleArr = Array.isArray(productBundle) ? productBundle : [];
+  var normalizedBundles = bundleArr.map(function (item) {
+    var _ref, _item$bundle_id;
+    return {
+      bundle_id: Number((_ref = (_item$bundle_id = item === null || item === void 0 ? void 0 : item.bundle_id) !== null && _item$bundle_id !== void 0 ? _item$bundle_id : item === null || item === void 0 ? void 0 : item.id) !== null && _ref !== void 0 ? _ref : 0) || 0,
+      product_id: Number(item === null || item === void 0 ? void 0 : item.product_id) || 0,
+      num: typeof (item === null || item === void 0 ? void 0 : item.num) === 'number' && !Number.isNaN(item.num) ? Math.max(1, Math.floor(item.num)) : 1
+    };
+  }).sort(function (p, q) {
+    if (p.bundle_id !== q.bundle_id) return p.bundle_id - q.bundle_id;
+    if (p.product_id !== q.product_id) return p.product_id - q.product_id;
+    return p.num - q.num;
+  });
+  return JSON.stringify([normalizedOpts, normalizedBundles]);
+}
+
+/**
+ * removeProductFromOrder 仅传 SKU 时的通配 identity（对象上未声明选项键）。
+ * 与显式 `product_option_item: []` 区分：后者只匹配「无选项」行。
+ */
+export function isSkuOnlyDeleteIdentity(x) {
+  if (x.identity_key) return false;
+  return !('product_option_item' in x) && !('product_bundle' in x);
+}
+function fingerprintForIdentityWithOptionKeys(x) {
+  var row = x;
+  var opts = 'product_option_item' in row ? Array.isArray(row.product_option_item) ? row.product_option_item : [] : [];
+  var buds = 'product_bundle' in row ? Array.isArray(row.product_bundle) ? row.product_bundle : [] : [];
+  return buildProductLineFingerprint(opts, buds);
+}
+
+/**
+ * 判断两个商品 identity 是否匹配（不透明 identity 契约）。
+ *
+ * 调用约定：始终 `isIdentityMatch(line, callerIdentity)`。
+ * - 若 SKU（product_id + product_variant_id）不一致 → 不匹配。
+ * - **双方都带** `identity_key` → 严格字符串相等比较（不再猜测合成 key / metadata 桥接）。
+ *   这是 opaque identity 契约的标准路径：UI 删改时透传 SDK 回灌的 identity_key。
+ * - 否则（即至少一侧未声明 identity_key）→ 进入「SKU 通配 / 显式空选项 / 指纹」回退路径，
+ *   忽略线侧 identity_key，按内容语义匹配。这给「行已 opaque、调用方却想按 SKU 通配 / 选项指纹删除」留兼容入口。
  */
 export function isIdentityMatch(a, b) {
   if (a.product_id !== b.product_id || a.product_variant_id !== b.product_variant_id) return false;
-  if (!a.identity_key && !b.identity_key) return true;
-  return a.identity_key === b.identity_key;
+  var aHasKey = typeof a.identity_key === 'string' && a.identity_key.length > 0;
+  var bHasKey = typeof b.identity_key === 'string' && b.identity_key.length > 0;
+  if (aHasKey && bHasKey) return a.identity_key === b.identity_key;
+  if (isSkuOnlyDeleteIdentity(a) || isSkuOnlyDeleteIdentity(b)) return true;
+  return fingerprintForIdentityWithOptionKeys(a) === fingerprintForIdentityWithOptionKeys(b);
 }
 
 /**
@@ -387,34 +452,35 @@ export function getProductIdentityIndex(products, identity) {
 }
 
 /**
- * 对外部传入的商品对象做归一化：
+ * 对外部传入的商品对象做归一化（v2 composite 语义）：
  * - 补全可选字段默认值（未传则使用兜底值，避免后续计算时因 undefined 导致异常）
  * - 对 num 调用 getSafeProductNum 做安全处理
  * - 保留 _origin 供后续业务流程（如促销规则）使用
+ *
+ * 价格字段语义（metadata 权威源 + composite 派生）：
+ * - `metadata.source_product_price`：主商品/variant 基础价（已应用报价单），**不含 option**、
+ *   **不含折扣**。是推导 main_product_* 的起点。variant 分支优先读 `metadata.origin.variant[vid].price`。
+ * - `metadata.main_product_original_price`：`source + Σ(option.price × option.num)`，**含 option**、
+ *   **不含折扣**。
+ * - `metadata.main_product_selling_price`：`main_product_original_price - 主商品券 per-unit amount`，
+ *   **含 option**、**含折扣**。
+ * - 行级 `selling_price` = `main_product_selling_price + Σ(bundle_selling_price × num)`。
+ * - 行级 `original_price` = `main_product_original_price + Σ(bundle 原价 × num)`。
+ *
+ * 迁移与幂等：
+ * - `metadata.price_schema_version === 2` → 已新语义归一化，保留 main_product_* 原值（保留折扣）。
+ * - 其它情况（v1 / 缺字段 / 无 metadata）→ 按"main_product_selling_price 曾是 main-only"的旧约定
+ *   反推 legacyDiscount，再以新 source + options 基准重算。最终统一打上 `price_schema_version: 2`。
+ * - 因此多次 normalize 不会重复叠加 option/bundle。
  */
 export function normalizeOrderProduct(product) {
-  var _product$is_charge_ta;
+  var _metadata$origin, _variantList$find, _product$is_charge_ta;
   var metadata = _objectSpread({}, product.metadata || {});
-  if (product.identity_key && !metadata.unique_identification_number) {
-    metadata.unique_identification_number = product.identity_key;
-  }
-
-  // selling_price：券后成交单价；original_price：券前店铺售价。
-  // 初次加购时两者相等（入口层应保证 caller 传的 original_price == selling_price）；
-  // 券应用后由 Rules 引擎只改动 selling_price，保留 original_price 以便还原 / 展示划线对比。
-  // 注意：这里 caller 若显式传入了 original_price（例如 Rules 回写或单测场景），要尊重该值，
-  //       让券后状态能正确通过再次 normalize。
-  var resolvedSellingPrice = product.selling_price || '0.00';
-  var resolvedOriginalPrice = product.original_price || resolvedSellingPrice;
-  if (metadata.main_product_original_price === undefined) {
-    metadata.main_product_original_price = resolvedOriginalPrice;
-  }
-  if (metadata.main_product_selling_price === undefined) {
-    metadata.main_product_selling_price = resolvedSellingPrice;
-  }
-  if (metadata.source_product_price === undefined) {
-    var _ref, _product$_origin$pric, _product$_origin, _product$_origin2;
-    metadata.source_product_price = (_ref = (_product$_origin$pric = (_product$_origin = product._origin) === null || _product$_origin === void 0 ? void 0 : _product$_origin.price) !== null && _product$_origin$pric !== void 0 ? _product$_origin$pric : (_product$_origin2 = product._origin) === null || _product$_origin2 === void 0 ? void 0 : _product$_origin2.base_price) !== null && _ref !== void 0 ? _ref : resolvedSellingPrice;
+  // 不透明 identity 契约：每条订单行必须带 identity_key。
+  // 调用方未传时由 SDK 自动生成 UUID，后续 update/remove 只做严格比对，避免猜测合成 key。
+  var resolvedIdentityKey = product.identity_key && String(product.identity_key).length > 0 ? String(product.identity_key) : createUuidV4();
+  if (!metadata.unique_identification_number) {
+    metadata.unique_identification_number = resolvedIdentityKey;
   }
   var normalizedBundle = (product.product_bundle || []).map(function (item) {
     var _ref2, _item$bundle_selling_, _ref3, _ref4, _item$custom_price;
@@ -423,20 +489,104 @@ export function normalizeOrderProduct(product) {
       custom_price: (_ref3 = (_ref4 = (_item$custom_price = item.custom_price) !== null && _item$custom_price !== void 0 ? _item$custom_price : item.bundle_selling_price) !== null && _ref4 !== void 0 ? _ref4 : item.price) !== null && _ref3 !== void 0 ? _ref3 : '0.00'
     });
   });
+  var normalizedOptions = product.product_option_item || [];
+  var optionSum = sumOptionUnitPrice(normalizedOptions);
+
+  // 1) 解析 source_product_price。
+  // 优先级：
+  //   1) metadata.source_product_price（v2 权威）
+  //   2) variantPrice（命中 variant_id，从 metadata.origin.variant[vid].price 读）
+  //   3) _origin.price / _origin.base_price（后端语义的基础价）
+  //   4) v1 兼容：无 v2 标记但存在 metadata.main_product_original_price（v1 main-only，即旧 source）
+  //   5) 入参 original_price（v1 addProduct 约定：original_price 为 pre-discount 基础价）
+  //   6) 入参 selling_price（最末兜底，新添加路径 caller 只给 selling_price）
+  var isV2 = metadata.price_schema_version === 2 || metadata.price_schema_version === '2';
+  var variantId = Number(product.product_variant_id || 0);
+  var variantList = variantId ? metadata === null || metadata === void 0 || (_metadata$origin = metadata.origin) === null || _metadata$origin === void 0 ? void 0 : _metadata$origin.variant : null;
+  var variantPrice = Array.isArray(variantList) ? (_variantList$find = variantList.find(function (v) {
+    return Number(v === null || v === void 0 ? void 0 : v.id) === variantId;
+  })) === null || _variantList$find === void 0 ? void 0 : _variantList$find.price : undefined;
+  var resolvedSource = function (_product$_origin, _product$_origin2, _ref5, _product$original_pri) {
+    if (metadata.source_product_price !== undefined) {
+      return String(metadata.source_product_price);
+    }
+    if (variantPrice !== undefined && variantPrice !== null) {
+      return String(variantPrice);
+    }
+    var originPrice = (_product$_origin = product._origin) === null || _product$_origin === void 0 ? void 0 : _product$_origin.price;
+    if (originPrice !== undefined && originPrice !== null) {
+      return String(originPrice);
+    }
+    var originBasePrice = (_product$_origin2 = product._origin) === null || _product$_origin2 === void 0 ? void 0 : _product$_origin2.base_price;
+    if (originBasePrice !== undefined && originBasePrice !== null) {
+      return String(originBasePrice);
+    }
+    if (!isV2 && metadata.main_product_original_price !== undefined) {
+      return String(metadata.main_product_original_price);
+    }
+    return (_ref5 = (_product$original_pri = product.original_price) !== null && _product$original_pri !== void 0 ? _product$original_pri : product.selling_price) !== null && _ref5 !== void 0 ? _ref5 : '0.00';
+  }();
+
+  // 2) 派生 main_product_original_price（含 option、不含折扣）
+  var mainOriginalDec = new Decimal(Number(resolvedSource) || 0).plus(optionSum);
+  var mainOriginalStr = mainOriginalDec.toDecimalPlaces(2).toFixed(2);
+
+  // 3) 派生 main_product_selling_price（含 option、含主商品折扣）
+  //    - v2 数据：直接沿用 metadata.main_product_selling_price（保留折扣）
+  //    - v1 metadata：main_product_selling_price 旧语义是 main-only（≈ source-level 折后价），
+  //      反推 legacyDiscount = main_original(旧) - main_selling(旧)，再用新 main_original - legacyDiscount
+  //    - v1 addProduct 入参：top-level selling_price < original_price 表示主商品折扣；
+  //      用差额作为 legacyDiscount 映射到新 main_selling
+  //    - 其它：视为无折扣，main_selling = main_original
+  var mainSellingDec;
+  if (isV2 && metadata.main_product_selling_price != null) {
+    mainSellingDec = new Decimal(Number(metadata.main_product_selling_price) || 0);
+  } else if (metadata.main_product_selling_price != null && metadata.main_product_original_price != null) {
+    var legacyOriginal = new Decimal(Number(metadata.main_product_original_price) || 0);
+    var legacySelling = new Decimal(Number(metadata.main_product_selling_price) || 0);
+    var legacyDiscount = legacyOriginal.minus(legacySelling);
+    mainSellingDec = mainOriginalDec.minus(legacyDiscount);
+  } else if (product.original_price != null && product.selling_price != null && new Decimal(Number(product.original_price) || 0).greaterThan(new Decimal(Number(product.selling_price) || 0))) {
+    var topOriginal = new Decimal(Number(product.original_price) || 0);
+    var topSelling = new Decimal(Number(product.selling_price) || 0);
+    var _legacyDiscount = topOriginal.minus(topSelling);
+    mainSellingDec = mainOriginalDec.minus(_legacyDiscount);
+  } else {
+    mainSellingDec = mainOriginalDec;
+  }
+  var mainSellingStr = mainSellingDec.toDecimalPlaces(2).toFixed(2);
+
+  // 4) 落盘 metadata：三字段 + schema 版本 sentinel
+  metadata.source_product_price = resolvedSource;
+  metadata.main_product_original_price = mainOriginalStr;
+  metadata.main_product_selling_price = mainSellingStr;
+  metadata.price_schema_version = 2;
+
+  // 5) 合成行级 composite（main 已含 option，本步只叠 bundle）
+  var composedSellingPrice = composeLinePrice({
+    mainPrice: mainSellingStr,
+    bundle: normalizedBundle
+  });
+  var composedOriginalPrice = composeLinePrice({
+    mainPrice: mainOriginalStr,
+    bundle: normalizedBundle,
+    useOriginalBundle: true
+  });
   return {
     order_detail_id: product.order_detail_id || null,
     product_id: product.product_id,
     num: getSafeProductNum(product.num),
     product_variant_id: product.product_variant_id,
-    identity_key: product.identity_key,
-    product_option_item: product.product_option_item || [],
-    selling_price: resolvedSellingPrice,
-    original_price: resolvedOriginalPrice,
+    identity_key: resolvedIdentityKey,
+    product_option_item: normalizedOptions,
+    selling_price: composedSellingPrice,
+    original_price: composedOriginalPrice,
     tax_fee: product.tax_fee || '0.00',
     is_charge_tax: (_product$is_charge_ta = product.is_charge_tax) !== null && _product$is_charge_ta !== void 0 ? _product$is_charge_ta : 0,
     discount_list: product.discount_list || [],
     product_bundle: normalizedBundle,
     metadata: metadata,
+    note: product.note != null ? String(product.note) : '',
     _origin: product._origin
   };
 }
@@ -508,16 +658,54 @@ export function hasCustomCapacityProduct(products) {
   });
 }
 
+/**
+ * 根据预约规则商品的 resource.type 计算桌台是否已被"占满"。
+ * - single：只要有 `lastOrderId` 即视为占用
+ * - multiple：当前时间落在 `capacity_list[i]` 的 `[start_at, end_at]`（inclusive）内的 pax 之和 >= 总容量
+ * - 其他（'capacity' / undefined）：返回 false，不施加限制
+ */
+export function computeResourceIsFull(params) {
+  var resourceSelectType = params.resourceSelectType,
+    lastOrderId = params.lastOrderId,
+    capacityList = params.capacityList,
+    capacity = params.capacity;
+  if (resourceSelectType === 'single') return Boolean(lastOrderId);
+  if (resourceSelectType !== 'multiple') return false;
+  var totalCapacity = Number(capacity);
+  if (!Number.isFinite(totalCapacity) || totalCapacity <= 0) return false;
+  var now = dayjs();
+  var occupied = 0;
+  var _iterator8 = _createForOfIteratorHelper(capacityList || []),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var slot = _step8.value;
+      var start = dayjs(slot === null || slot === void 0 ? void 0 : slot.start_at);
+      var end = dayjs(slot === null || slot === void 0 ? void 0 : slot.end_at);
+      if (!start.isValid() || !end.isValid()) continue;
+      if ((now.isAfter(start) || now.isSame(start)) && (now.isBefore(end) || now.isSame(end))) {
+        var pax = Number(slot === null || slot === void 0 ? void 0 : slot.pax);
+        if (Number.isFinite(pax) && pax > 0) occupied += pax;
+      }
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+  return occupied >= totalCapacity;
+}
+
 /**
  * 在商品列表中找到第一个 `capacity.type === 'custom'` 的商品，取其 `custom` 数组第一项的 min/max。
  * 仅返回有限数字字段；若均无法解析则返回 `undefined`。
  */
 export function pickFirstCustomCapacityPaxBounds(products) {
-  var _iterator8 = _createForOfIteratorHelper(products),
-    _step8;
+  var _iterator9 = _createForOfIteratorHelper(products),
+    _step9;
   try {
-    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-      var p = _step8.value;
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var p = _step9.value;
       var cap = p === null || p === void 0 ? void 0 : p.capacity;
       if (!cap || cap.type !== 'custom') continue;
       if (!Array.isArray(cap.custom) || cap.custom.length === 0) continue;
@@ -536,9 +724,41 @@ export function pickFirstCustomCapacityPaxBounds(products) {
       if (out.min !== undefined || out.max !== undefined) return out;
     }
   } catch (err) {
-    _iterator8.e(err);
+    _iterator9.e(err);
   } finally {
-    _iterator8.f();
+    _iterator9.f();
+  }
+  return undefined;
+}
+
+/**
+ * 第一个 `capacity.type === 'custom'` 的商品，取其 `custom[0].id`（提交 booking metadata.capacity 维度 id）。
+ * 无匹配时返回 `undefined`，调用方应回退为 `0`。
+ */
+export function pickFirstCustomCapacityDimensionId(products) {
+  var _iterator10 = _createForOfIteratorHelper(products),
+    _step10;
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var p = _step10.value;
+      var cap = p === null || p === void 0 ? void 0 : p.capacity;
+      if (!cap || cap.type !== 'custom') continue;
+      if (!Array.isArray(cap.custom) || cap.custom.length === 0) continue;
+      var row = cap.custom[0];
+      if (!row || _typeof(row) !== 'object') continue;
+      var id = row.id;
+      if (id === null || id === undefined || id === '') continue;
+      if (typeof id === 'number' && Number.isFinite(id)) return id;
+      if (typeof id === 'string') {
+        var trimmed = id.trim();
+        if (!trimmed) continue;
+        return trimmed;
+      }
+    }
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
   }
   return undefined;
 }

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

@@ -2,6 +2,7 @@ import { Module, ModuleOptions, PisellCore } from '../../types';
 import { BaseModule } from '../../modules/BaseModule';
 import { VenueBookingAddLogParams, VenueBookingSlotConfig, VenueDateSummaryItem, VenueSlotSelection, VenueTimeSlotGrid } from './types';
 import type { ScanOrderOrderProduct, ScanOrderOrderProductIdentity } from '../ScanOrder/types';
+import type { UpdateProductInOrderParams } from '../../modules/Order/types';
 import type { OpenDataAvailabilityResult } from '../../modules/OpenData';
 import type { ProductData } from '../../modules/Product/types';
 import { type CartItemSummary, type PaxInfo, type QuantityCheckResult, type QuantityLimitResult } from '../../model/strategy/adapter/itemRule';
@@ -92,25 +93,48 @@ export declare class VenueBookingImpl extends BaseModule implements Module {
     /**
      * 切换单个时段的选中状态（选中/取消）。
      * 内部自动处理连续时段的合并与拆分，订单是唯一真相源。
+     *
+     * slot.productId 指定当前操作针对的是该 resourceId 下的哪一个商品。
+     * 同一资源下不同 productId 之间互相隔离，不会相互合并。
      */
     toggleSlot(slot: VenueSlotSelection): Promise<ScanOrderOrderProduct[]>;
     /**
      * 获取某资源当前选中的所有独立时段（从订单中解析）。
+     * 不传 productId 时返回该资源下所有商品的选中时段；传了则精确匹配。
      */
-    getSelectedSlotsForResource(resourceId: number | string): VenueSlotSelection[];
+    getSelectedSlotsForResource(resourceId: number | string, productId?: number): VenueSlotSelection[];
+    /** getSelectedSlotsForResource 的 (resourceId, productId) 精确版，内部使用。 */
+    private getSelectedSlotsForResourceProduct;
     /**
      * 判断某个时段是否已选中。
+     * 不传 productId 时：只要该资源下任一商品在 startTime 被选中即返回 true；传了则精确匹配。
      */
-    isSlotSelected(resourceId: number | string, startTime: string): boolean;
+    isSlotSelected(resourceId: number | string, startTime: string, productId?: number): boolean;
     /**
-     * 获取所有已选时段（按资源分组）。
+     * 判断指定 (resourceId, productId, startTime) 格子是否应因其它已选项而被禁用。
+     * 规则：
+     * 1) 同一 resourceId 下若已选了另一个 productId 的同 startTime → 禁用
+     * 2) 当前 resource 是组合资源：若其任一 child resource 在 startTime 被选中 → 禁用
+     * 3) 当前 resource 是某些组合资源的 child：若该组合资源在 startTime 被选中 → 禁用
+     * 4) 两个组合资源的 child 集合有交集，且对方在该 startTime 被选中 → 禁用
+     */
+    isSlotDisabledBySelection(params: {
+        resourceId: number | string;
+        productId: number;
+        startTime: string;
+    }): boolean;
+    /**
+     * 获取所有已选时段（按资源分组）。每个 slot 上带 productId，便于 UI 做 per-product 判定。
      */
     getAllSelectedSlots(): Map<number | string, VenueSlotSelection[]>;
     /**
-     * 对指定资源的订单商品进行 reconcile：
+     * 对指定 (resourceId, productId) 的订单商品进行 reconcile：
      * 清除旧商品 → 合并连续时段 → 重新写入。
+     * 同一场地下不同商品互不干扰，各自单独 reconcile。
      */
-    private reconcileOrderForResource;
+    private reconcileOrderForResourceProduct;
+    /** 给定一个父 rawResource，返回其 combined_resource.resource_ids 对应的子 rawResource 列表。 */
+    private getCombinedChildRawResources;
     setSlotConfig(config: Partial<VenueBookingSlotConfig>): void;
     getSlotConfig(): VenueBookingSlotConfig;
     loadSchedules(): Promise<void>;
@@ -142,11 +166,7 @@ export declare class VenueBookingImpl extends BaseModule implements Module {
     getSummary(): Promise<import("./types").ScanOrderSummary>;
     submitOrder<T = any>(): Promise<T>;
     addProductToOrder(product: Partial<ScanOrderOrderProduct> & ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
-    updateProductInOrder(params: {
-        product_id: number | null;
-        product_variant_id: number;
-        updates: Partial<ScanOrderOrderProduct>;
-    }): Promise<ScanOrderOrderProduct[]>;
+    updateProductInOrder(params: UpdateProductInOrderParams): Promise<ScanOrderOrderProduct[]>;
     removeProductFromOrder(identity: ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
     getProductList(): Promise<ProductData[]>;
     private loadOpenDataConfig;