@pisell/pisellos 2.2.230 → 2.2.232

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

@@ -79,6 +79,10 @@ export interface ILoadProductsParams {
     with_count?: string[];
     /** 是否返回日程信息 */
     with_schedule?: number;
+    /** 扩展商品类型过滤 */
+    extension_type?: string[];
+    /** 商品发布状态 */
+    status?: string;
 }
 /**
  * 加载商品详情的参数

package/dist/solution/BookingTicket/utils/cartView.js

@@ -33,6 +33,17 @@ function indexProductsByUid(lines) {
   }, {});
 }
 
+/**
+ * 判断商品行是否是促销赠品行。
+ *
+ * @example
+ * isGiftProductLine({ metadata: { _giftInfo: {} } } as any); // true
+ */
+function isGiftProductLine(line) {
+  var _line$metadata2;
+  return Boolean(line === null || line === void 0 || (_line$metadata2 = line.metadata) === null || _line$metadata2 === void 0 ? void 0 : _line$metadata2._giftInfo);
+}
+
 /**
  * 构建购物车 UI 视图：bookings 平铺附带关联商品；items 仅含未关联 booking 的商品行。
  *
@@ -47,29 +58,32 @@ export function buildCartView(lines, bookings) {
   var claimedUids = new Set();
   var cartBookings = bookingList.filter(function (booking) {
     return booking.parent_id !== 0;
-  }).map(function (booking) {
+  }).reduce(function (acc, booking) {
     var uid = booking === null || booking === void 0 ? void 0 : booking.product_uid;
     var product = null;
     if (uid !== undefined && uid !== null && uid !== '') {
       var key = String(uid);
       if (!claimedUids.has(key)) {
         var line = linesByUid[key];
+        // 赠品预约只作为提交数据保留，不在购物车顶部预约卡片区展示。
+        if (isGiftProductLine(line)) return acc;
         if (line) {
           claimedUids.add(key);
           product = line;
         }
       }
     }
-    return _objectSpread(_objectSpread({}, booking), {}, {
+    acc.push(_objectSpread(_objectSpread({}, booking), {}, {
       _extend: {
         product: product
       }
-    });
-  });
+    }));
+    return acc;
+  }, []);
   var items = productLines.filter(function (line) {
-    var _line$metadata2, _line$metadata3;
+    var _line$metadata3;
     // 促销赠品行仅通过主商品 Gift 行展示，不在 items 单独占一行（对齐 legacy `isGift: !!_giftInfo`）
-    if ((_line$metadata2 = line.metadata) !== null && _line$metadata2 !== void 0 && _line$metadata2._giftInfo) return false;
+    if (isGiftProductLine(line)) return false;
     var uid = (_line$metadata3 = line.metadata) === null || _line$metadata3 === void 0 ? void 0 : _line$metadata3.unique_identification_number;
     if (uid === undefined || uid === null || uid === '') return true;
     return !claimedUids.has(String(uid));

package/dist/solution/BookingTicket/utils/resolveBestAddTimePlan.d.ts

@@ -0,0 +1,189 @@
+/**
+ * 计算指定加时时长下的最优购买方案。
+ *
+ * 输入的商品结构来自旧版 booking addTimeModal 的加时商品配置映射：
+ * - `minMinutes`：该商品第一次可选择的最小时长。
+ * - `maxMinutes`：单次购买该商品可覆盖的最大时长。
+ * - `unitMinutes`：超过最小时长后，每次递增的时长切片。
+ * - `price`：每个 `unitMinutes` 切片的价格。
+ * - `unlimited`：固定价格商品，可覆盖任意目标时长。
+ *
+ * 算法流程：
+ *
+ * ```
+ * products
+ *   |
+ *   v
+ * 将每个普通商品展开成有限候选档位
+ *   商品 A: min=30, max=60, unit=10, price=10
+ *   => 30m/$30, 40m/$40, 50m/$50, 60m/$60
+ *   |
+ *   v
+ * 单独加入 unlimited 候选
+ *   unlimited 商品 => targetMinutes / 固定商品价格
+ *   |
+ *   v
+ * 按 covered minutes 做动态规划
+ *   dp[minutes] = 正好覆盖 `minutes` 时的最低价候选组合
+ *   |
+ *   v
+ * 从所有 dp[minutes >= targetMinutes] 中挑选最优方案
+ * ```
+ *
+ * 候选档位生成刻意对齐旧版 addTimeModal：
+ * `totalPrice = minutes / unitMinutes * price`.
+ * 例如 `minMinutes=30`、`unitMinutes=10`、`price=10` 时：
+ * - 30 分钟 => 30 / 10 * 10 = 30
+ * - 60 分钟 => 60 / 10 * 10 = 60
+ *
+ * 目标时长不要求精确命中某个档位，只需要覆盖即可。例如目标是 51 分钟时，
+ * 60 分钟档位可以作为候选。动态规划也允许跨商品组合，例如商品 A 的 30m
+ * 加上商品 B 的 30m。最终方案按以下优先级比较：
+ * 1. 总价更低；
+ * 2. 超出时长更少，即 `coveredMinutes - targetMinutes` 更小；
+ * 3. 结果行数更少，让购买方案尽量简单。
+ *
+ * 典型匹配示例：
+ *
+ * 示例 1：精确命中，直接选择更便宜的商品。
+ * ```
+ * target = 30
+ * 商品 A: min=30, max=30, unit=30, price=10 => 30m/$10
+ * 商品 B: min=30, max=30, unit=30, price=8  => 30m/$8
+ * 结果：选择商品 B，coveredMinutes=30，totalPrice=8
+ * ```
+ *
+ * 示例 2：目标时长落在两个档位之间，向上选择可覆盖的档位。
+ * ```
+ * target = 51
+ * 商品 A: min=30, max=120, unit=10, price=10
+ * 候选：30m/$30, 40m/$40, 50m/$50, 60m/$60 ...
+ * 结果：50m 不足以覆盖 51m，因此选择 60m/$60
+ * ```
+ *
+ * 示例 3：不同商品都能覆盖同一目标时长，比较最终价格。
+ * ```
+ * target = 51
+ * 商品 A: min=30, max=120, unit=10, price=10 => 60m/$60
+ * 商品 B: min=30, max=120, unit=30, price=25 => 60m/$50
+ * 结果：两个方案都覆盖 60m，但商品 B 更便宜，所以选择商品 B
+ * ```
+ *
+ * 示例 4：允许跨商品组合，组合价更低时会选择组合。
+ * ```
+ * target = 90
+ * 商品 A: min=30, max=30, unit=30, price=5  => 30m/$5
+ * 商品 B: min=60, max=60, unit=60, price=8  => 60m/$8
+ * 商品 C: min=90, max=90, unit=90, price=20 => 90m/$20
+ * 结果：商品 A + 商品 B = 90m/$13，比商品 C 更便宜
+ * ```
+ *
+ * 示例 5：允许重复购买同一个候选档位。
+ * ```
+ * target = 90
+ * 商品 A: min=30, max=30, unit=30, price=5 => 30m/$5
+ * 结果：购买 3 份商品 A，coveredMinutes=90，totalPrice=15，
+ * lines 中会合并为一行：minutes=30，quantity=3
+ * ```
+ *
+ * 示例 6：unlimited 可以覆盖任意目标时长，并参与价格比较。
+ * ```
+ * target = 180
+ * 商品 A: min=30, max=120, unit=30, price=10
+ * 商品 B: unlimited=true, price=35
+ * 普通商品可以组合成 180m，例如 120m + 60m，总价 $60
+ * unlimited 商品固定 $35
+ * 结果：选择 unlimited 商品，coveredMinutes=180，totalPrice=35
+ * ```
+ *
+ * 示例 7：unlimited 不一定优先，普通商品更便宜时选择普通商品。
+ * ```
+ * target = 60
+ * 商品 A: min=30, max=60, unit=30, price=10 => 60m/$20
+ * 商品 B: unlimited=true, price=50
+ * 结果：选择商品 A 的 60m 档位
+ * ```
+ *
+ * 示例 8：价格相同，优先选择超出时长更少的方案。
+ * ```
+ * target = 51
+ * 商品 A: 60m/$20
+ * 商品 B: 90m/$20
+ * 结果：选择 60m，因为 overage=9，小于 90m 的 overage=39
+ * ```
+ *
+ * 示例 9：价格和覆盖时长都相同，优先选择结果行数更少的方案。
+ * ```
+ * target = 60
+ * 商品 A: 60m/$20
+ * 商品 B: 30m/$10
+ * 商品 C: 30m/$10
+ * 结果：商品 A 单行方案和 B+C 两行方案价格、时长相同，选择商品 A
+ * ```
+ *
+ * 示例 10：没有任何有效商品时返回 `NO_PRODUCTS`。
+ * ```
+ * target = 30
+ * products = []
+ * 结果：available=false，unavailableReason='NO_PRODUCTS'
+ * ```
+ *
+ * 示例 11：有商品但没有可用候选时返回 `NO_COVERAGE`。
+ * ```
+ * target = 30
+ * 商品 A: price=0，或 minMinutes 缺失/无效
+ * 结果：available=false，unavailableReason='NO_COVERAGE'
+ * ```
+ *
+ * 示例 12：目标时长小于等于 0 时无需购买。
+ * ```
+ * target = 0
+ * 结果：available=true，coveredMinutes=0，totalPrice=0，lines=[]
+ * ```
+ *
+ * 搜索边界：
+ * 有限档位只需要搜索到 `targetMinutes + maxFiniteCandidateMinutes`。
+ * 这里的 `maxFiniteCandidateMinutes` 是所有普通候选档位里的最大时长。
+ * 例如目标是 51 分钟，最大普通档位是 120 分钟，则只搜索到 171 分钟。
+ * 如果某个组合覆盖了 180 分钟，那么移除其中任意一个普通档位后，剩余时长
+ * 仍然有机会覆盖 51 分钟，而且价格一定不会更高，所以 180 分钟这个组合不
+ * 可能是最优解。
+ */
+export interface AddTimeProduct {
+    id: string | number;
+    title?: string;
+    price: number;
+    minMinutes?: number;
+    maxMinutes?: number;
+    unitMinutes?: number;
+    unlimited?: boolean;
+}
+export interface AddTimePlanLine {
+    productId: string | number;
+    productTitle?: string;
+    minutes: number;
+    quantity: number;
+    unitPrice: number;
+    totalPrice: number;
+    unlimited?: boolean;
+}
+export interface AddTimePlan {
+    available: boolean;
+    unavailableReason?: 'NO_PRODUCTS' | 'NO_COVERAGE';
+    targetMinutes: number;
+    coveredMinutes: number;
+    totalPrice: number;
+    lines: AddTimePlanLine[];
+}
+interface AddTimeCandidate {
+    productId: string | number;
+    productTitle?: string;
+    minutes: number;
+    unitPrice: number;
+    totalPrice: number;
+    unlimited?: boolean;
+}
+export declare const ADD_TIME_UNIT_MINUTES: readonly [10, 15, 20, 30, 45, 60];
+export declare function buildAddTimeCandidates(products: AddTimeProduct[]): AddTimeCandidate[];
+export declare function resolveBestAddTimePlan(products: AddTimeProduct[], targetMinutes: number): AddTimePlan;
+export {};

package/dist/solution/BookingTicket/utils/resolveBestAddTimePlan.js

@@ -0,0 +1,429 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+/**
+ * 计算指定加时时长下的最优购买方案。
+ *
+ * 输入的商品结构来自旧版 booking addTimeModal 的加时商品配置映射：
+ * - `minMinutes`：该商品第一次可选择的最小时长。
+ * - `maxMinutes`：单次购买该商品可覆盖的最大时长。
+ * - `unitMinutes`：超过最小时长后，每次递增的时长切片。
+ * - `price`：每个 `unitMinutes` 切片的价格。
+ * - `unlimited`：固定价格商品，可覆盖任意目标时长。
+ *
+ * 算法流程：
+ *
+ * ```
+ * products
+ *   |
+ *   v
+ * 将每个普通商品展开成有限候选档位
+ *   商品 A: min=30, max=60, unit=10, price=10
+ *   => 30m/$30, 40m/$40, 50m/$50, 60m/$60
+ *   |
+ *   v
+ * 单独加入 unlimited 候选
+ *   unlimited 商品 => targetMinutes / 固定商品价格
+ *   |
+ *   v
+ * 按 covered minutes 做动态规划
+ *   dp[minutes] = 正好覆盖 `minutes` 时的最低价候选组合
+ *   |
+ *   v
+ * 从所有 dp[minutes >= targetMinutes] 中挑选最优方案
+ * ```
+ *
+ * 候选档位生成刻意对齐旧版 addTimeModal：
+ * `totalPrice = minutes / unitMinutes * price`.
+ * 例如 `minMinutes=30`、`unitMinutes=10`、`price=10` 时：
+ * - 30 分钟 => 30 / 10 * 10 = 30
+ * - 60 分钟 => 60 / 10 * 10 = 60
+ *
+ * 目标时长不要求精确命中某个档位，只需要覆盖即可。例如目标是 51 分钟时，
+ * 60 分钟档位可以作为候选。动态规划也允许跨商品组合，例如商品 A 的 30m
+ * 加上商品 B 的 30m。最终方案按以下优先级比较：
+ * 1. 总价更低；
+ * 2. 超出时长更少，即 `coveredMinutes - targetMinutes` 更小；
+ * 3. 结果行数更少，让购买方案尽量简单。
+ *
+ * 典型匹配示例：
+ *
+ * 示例 1：精确命中，直接选择更便宜的商品。
+ * ```
+ * target = 30
+ * 商品 A: min=30, max=30, unit=30, price=10 => 30m/$10
+ * 商品 B: min=30, max=30, unit=30, price=8  => 30m/$8
+ * 结果：选择商品 B，coveredMinutes=30，totalPrice=8
+ * ```
+ *
+ * 示例 2：目标时长落在两个档位之间，向上选择可覆盖的档位。
+ * ```
+ * target = 51
+ * 商品 A: min=30, max=120, unit=10, price=10
+ * 候选：30m/$30, 40m/$40, 50m/$50, 60m/$60 ...
+ * 结果：50m 不足以覆盖 51m，因此选择 60m/$60
+ * ```
+ *
+ * 示例 3：不同商品都能覆盖同一目标时长，比较最终价格。
+ * ```
+ * target = 51
+ * 商品 A: min=30, max=120, unit=10, price=10 => 60m/$60
+ * 商品 B: min=30, max=120, unit=30, price=25 => 60m/$50
+ * 结果：两个方案都覆盖 60m，但商品 B 更便宜，所以选择商品 B
+ * ```
+ *
+ * 示例 4：允许跨商品组合，组合价更低时会选择组合。
+ * ```
+ * target = 90
+ * 商品 A: min=30, max=30, unit=30, price=5  => 30m/$5
+ * 商品 B: min=60, max=60, unit=60, price=8  => 60m/$8
+ * 商品 C: min=90, max=90, unit=90, price=20 => 90m/$20
+ * 结果：商品 A + 商品 B = 90m/$13，比商品 C 更便宜
+ * ```
+ *
+ * 示例 5：允许重复购买同一个候选档位。
+ * ```
+ * target = 90
+ * 商品 A: min=30, max=30, unit=30, price=5 => 30m/$5
+ * 结果：购买 3 份商品 A，coveredMinutes=90，totalPrice=15，
+ * lines 中会合并为一行：minutes=30，quantity=3
+ * ```
+ *
+ * 示例 6：unlimited 可以覆盖任意目标时长，并参与价格比较。
+ * ```
+ * target = 180
+ * 商品 A: min=30, max=120, unit=30, price=10
+ * 商品 B: unlimited=true, price=35
+ * 普通商品可以组合成 180m，例如 120m + 60m，总价 $60
+ * unlimited 商品固定 $35
+ * 结果：选择 unlimited 商品，coveredMinutes=180，totalPrice=35
+ * ```
+ *
+ * 示例 7：unlimited 不一定优先，普通商品更便宜时选择普通商品。
+ * ```
+ * target = 60
+ * 商品 A: min=30, max=60, unit=30, price=10 => 60m/$20
+ * 商品 B: unlimited=true, price=50
+ * 结果：选择商品 A 的 60m 档位
+ * ```
+ *
+ * 示例 8：价格相同，优先选择超出时长更少的方案。
+ * ```
+ * target = 51
+ * 商品 A: 60m/$20
+ * 商品 B: 90m/$20
+ * 结果：选择 60m，因为 overage=9，小于 90m 的 overage=39
+ * ```
+ *
+ * 示例 9：价格和覆盖时长都相同，优先选择结果行数更少的方案。
+ * ```
+ * target = 60
+ * 商品 A: 60m/$20
+ * 商品 B: 30m/$10
+ * 商品 C: 30m/$10
+ * 结果：商品 A 单行方案和 B+C 两行方案价格、时长相同，选择商品 A
+ * ```
+ *
+ * 示例 10：没有任何有效商品时返回 `NO_PRODUCTS`。
+ * ```
+ * target = 30
+ * products = []
+ * 结果：available=false，unavailableReason='NO_PRODUCTS'
+ * ```
+ *
+ * 示例 11：有商品但没有可用候选时返回 `NO_COVERAGE`。
+ * ```
+ * target = 30
+ * 商品 A: price=0，或 minMinutes 缺失/无效
+ * 结果：available=false，unavailableReason='NO_COVERAGE'
+ * ```
+ *
+ * 示例 12：目标时长小于等于 0 时无需购买。
+ * ```
+ * target = 0
+ * 结果：available=true，coveredMinutes=0，totalPrice=0，lines=[]
+ * ```
+ *
+ * 搜索边界：
+ * 有限档位只需要搜索到 `targetMinutes + maxFiniteCandidateMinutes`。
+ * 这里的 `maxFiniteCandidateMinutes` 是所有普通候选档位里的最大时长。
+ * 例如目标是 51 分钟，最大普通档位是 120 分钟，则只搜索到 171 分钟。
+ * 如果某个组合覆盖了 180 分钟，那么移除其中任意一个普通档位后，剩余时长
+ * 仍然有机会覆盖 51 分钟，而且价格一定不会更高，所以 180 分钟这个组合不
+ * 可能是最优解。
+ */
+
+export var ADD_TIME_UNIT_MINUTES = [10, 15, 20, 30, 45, 60];
+var toPositiveNumber = function toPositiveNumber(value) {
+  var n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : null;
+};
+var normalizeTargetMinutes = function normalizeTargetMinutes(minutes) {
+  var n = Number(minutes);
+  return Number.isFinite(n) ? Math.max(0, Math.ceil(n)) : 0;
+};
+var gcd = function gcd(a, b) {
+  var x = Math.abs(a);
+  var y = Math.abs(b);
+  while (y !== 0) {
+    var next = x % y;
+    x = y;
+    y = next;
+  }
+  return x;
+};
+var getDpStepMinutes = function getDpStepMinutes(candidates) {
+  return candidates.reduce(function (current, candidate) {
+    return gcd(current, candidate.minutes);
+  }, 0) || 1;
+};
+var comparePlans = function comparePlans(left, right) {
+  if (!left) return right;
+
+  // 第一优先级：总价更低。例：同样覆盖 60 分钟，$50 优先于 $60。
+  if (right.totalPrice !== left.totalPrice) {
+    return right.totalPrice < left.totalPrice ? right : left;
+  }
+
+  // 第二优先级：价格相同时，选择超出目标更少的方案。例：target=51 时，60m 优先于 90m。
+  var leftOverage = left.coveredMinutes - left.targetMinutes;
+  var rightOverage = right.coveredMinutes - right.targetMinutes;
+  if (rightOverage !== leftOverage) {
+    return rightOverage < leftOverage ? right : left;
+  }
+
+  // 第三优先级：价格和超出时长都相同时，选择购买行数更少的方案，减少下单复杂度。
+  return right.lines.length < left.lines.length ? right : left;
+};
+var toPlanLine = function toPlanLine(candidate) {
+  return {
+    productId: candidate.productId,
+    productTitle: candidate.productTitle,
+    minutes: Number.isFinite(candidate.minutes) ? candidate.minutes : 0,
+    quantity: 1,
+    unitPrice: candidate.unitPrice,
+    totalPrice: candidate.totalPrice,
+    unlimited: candidate.unlimited
+  };
+};
+var mergePlanLines = function mergePlanLines(candidates) {
+  var map = new Map();
+  var _iterator = _createForOfIteratorHelper(candidates),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var candidate = _step.value;
+      // 同一个商品、同一个档位可以重复购买，合并成 quantity。例：30m 档买 3 次 => 一行 quantity=3。
+      var key = "".concat(candidate.productId, "-").concat(candidate.minutes, "-").concat(candidate.unlimited ? 'u' : 'n');
+      var existing = map.get(key);
+      if (existing) {
+        existing.quantity += 1;
+        existing.totalPrice += candidate.totalPrice;
+        continue;
+      }
+      map.set(key, toPlanLine(candidate));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return Array.from(map.values());
+};
+var restoreDpCandidates = function restoreDpCandidates(dp, finiteCandidates, index) {
+  var candidates = [];
+  var currentIndex = index;
+  while (currentIndex > 0) {
+    var current = dp[currentIndex];
+    if (!current || current.candidateIndex < 0) break;
+    candidates.push(finiteCandidates[current.candidateIndex]);
+    currentIndex = current.prevIndex;
+  }
+  return candidates.reverse();
+};
+export function buildAddTimeCandidates(products) {
+  var candidates = [];
+  var _iterator2 = _createForOfIteratorHelper(products),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _toPositiveNumber, _toPositiveNumber2;
+      var product = _step2.value;
+      // 价格无效的商品无法参与比价，直接跳过，避免生成 0 元或 NaN 候选。
+      var price = toPositiveNumber(product.price);
+      if (price == null) continue;
+      if (product.unlimited) {
+        // unlimited 是固定价商品，可覆盖任意目标时长；这里先用 Infinity 标记，最终按 targetMinutes 输出。
+        candidates.push({
+          productId: product.id,
+          productTitle: product.title,
+          minutes: Number.POSITIVE_INFINITY,
+          unitPrice: price,
+          totalPrice: price,
+          unlimited: true
+        });
+        continue;
+      }
+
+      // 普通商品必须有有效的起购时长，否则无法知道第一档应该从哪里开始。
+      var minMinutes = toPositiveNumber(product.minMinutes);
+      if (minMinutes == null) continue;
+
+      // 旧版配置中 max/unit 可能缺失：缺失时退化为只有 minMinutes 这一档。
+      var maxMinutes = (_toPositiveNumber = toPositiveNumber(product.maxMinutes)) !== null && _toPositiveNumber !== void 0 ? _toPositiveNumber : minMinutes;
+      var unitMinutes = (_toPositiveNumber2 = toPositiveNumber(product.unitMinutes)) !== null && _toPositiveNumber2 !== void 0 ? _toPositiveNumber2 : minMinutes;
+      // 当 maxMinutes 小于 minMinutes 时，至少保留 minMinutes 这一档，避免错误配置导致无候选。
+      var safeMax = Math.max(minMinutes, maxMinutes);
+
+      // 将一个商品展开为多个可购买档位。例：min=30,max=60,unit=10 => 30/40/50/60 四个候选。
+      for (var minutes = minMinutes; minutes <= safeMax; minutes += unitMinutes) {
+        candidates.push({
+          productId: product.id,
+          productTitle: product.title,
+          minutes: minutes,
+          unitPrice: price,
+          // 对齐旧版 addTimeModal：每个 unit_duration 切片收一次 price。例：60/10*10=$60。
+          totalPrice: minutes / unitMinutes * price
+        });
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return candidates;
+}
+export function resolveBestAddTimePlan(products, targetMinutes) {
+  var _best;
+  // 目标时长按分钟向上取整，避免 50.2 分钟被当成 50 分钟而覆盖不足。
+  var normalizedTarget = normalizeTargetMinutes(targetMinutes);
+  if (normalizedTarget <= 0) {
+    // 目标时长为 0 或负数时表示无需加时，直接返回 0 元可用方案。
+    return {
+      available: true,
+      targetMinutes: 0,
+      coveredMinutes: 0,
+      totalPrice: 0,
+      lines: []
+    };
+  }
+  if (!products.length) {
+    return {
+      available: false,
+      unavailableReason: 'NO_PRODUCTS',
+      targetMinutes: normalizedTarget,
+      coveredMinutes: 0,
+      totalPrice: 0,
+      lines: []
+    };
+  }
+  var candidates = buildAddTimeCandidates(products);
+  // 普通候选参与 DP 组合；unlimited 单独比较，因为它本身可以覆盖任意时长，不需要组合。
+  var finiteCandidates = candidates.filter(function (item) {
+    return Number.isFinite(item.minutes);
+  });
+  var unlimitedCandidates = candidates.filter(function (item) {
+    return item.unlimited;
+  });
+  // 搜索上限只需要多看一个最大档位。超过这个范围的组合，去掉其中一个档位后通常仍可覆盖且更便宜。
+  var maxFiniteMinutes = Math.max.apply(Math, [0].concat(_toConsumableArray(finiteCandidates.map(function (item) {
+    return item.minutes;
+  }))));
+  var searchLimit = normalizedTarget + maxFiniteMinutes;
+  var best = null;
+  var _iterator3 = _createForOfIteratorHelper(unlimitedCandidates),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var unlimited = _step3.value;
+      // unlimited 按目标时长输出 coveredMinutes，但价格保持商品固定价，并参与普通方案的统一比价。
+      best = comparePlans(best, {
+        available: true,
+        targetMinutes: normalizedTarget,
+        coveredMinutes: normalizedTarget,
+        totalPrice: unlimited.totalPrice,
+        lines: [toPlanLine(_objectSpread(_objectSpread({}, unlimited), {}, {
+          minutes: normalizedTarget
+        }))]
+      });
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (finiteCandidates.length && searchLimit > 0) {
+    var stepMinutes = getDpStepMinutes(finiteCandidates);
+    var searchLimitIndex = Math.ceil(searchLimit / stepMinutes);
+    var targetIndex = Math.ceil(normalizedTarget / stepMinutes);
+    var finiteCandidateSteps = finiteCandidates.map(function (candidate) {
+      return candidate.minutes / stepMinutes;
+    });
+
+    // dp[x] 表示“刚好覆盖 x * stepMinutes 分钟”的当前最低价状态；状态只存前驱，最后再回溯生成明细。
+    var dp = [];
+    dp[0] = {
+      price: 0,
+      itemCount: 0,
+      prevIndex: -1,
+      candidateIndex: -1
+    };
+    for (var index = 0; index <= searchLimitIndex; index += 1) {
+      var current = dp[index];
+      // 当前压缩状态不可达时跳过。例：只有 30m 档且 step=30 时，dp[1] 才代表 30 分钟。
+      if (!current) continue;
+      for (var candidateIndex = 0; candidateIndex < finiteCandidates.length; candidateIndex += 1) {
+        // 尝试在当前组合后再买一个候选档位，形成新的覆盖时长。
+        var nextIndex = index + finiteCandidateSteps[candidateIndex];
+        if (nextIndex > searchLimitIndex) continue;
+        var candidate = finiteCandidates[candidateIndex];
+        var nextPrice = current.price + candidate.totalPrice;
+        var nextItemCount = current.itemCount + 1;
+        var prev = dp[nextIndex];
+
+        // 更新 dp[nextIndex]：价格更低则替换；价格相同则用更少档位，便于后续输出更简单的方案。
+        if (!prev || nextPrice < prev.price || nextPrice === prev.price && nextItemCount < prev.itemCount) {
+          dp[nextIndex] = {
+            price: nextPrice,
+            itemCount: nextItemCount,
+            prevIndex: index,
+            candidateIndex: candidateIndex
+          };
+        }
+      }
+    }
+
+    // 目标不要求精确命中：从 target 到 searchLimit 的所有可达方案里选最优。
+    for (var _index = targetIndex; _index <= searchLimitIndex; _index += 1) {
+      var _current = dp[_index];
+      if (!_current) continue;
+      var coveredMinutes = _index * stepMinutes;
+      best = comparePlans(best, {
+        available: true,
+        targetMinutes: normalizedTarget,
+        coveredMinutes: coveredMinutes,
+        totalPrice: _current.price,
+        lines: mergePlanLines(restoreDpCandidates(dp, finiteCandidates, _index))
+      });
+    }
+  }
+  return (_best = best) !== null && _best !== void 0 ? _best : {
+    available: false,
+    unavailableReason: 'NO_COVERAGE',
+    targetMinutes: normalizedTarget,
+    coveredMinutes: 0,
+    totalPrice: 0,
+    lines: []
+  };
+}