@pisell/pisellos 2.2.230 → 2.2.231

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

@@ -51,34 +51,41 @@ function indexProductsByUid(lines) {
     return acc;
   }, {});
 }
+function isGiftProductLine(line) {
+  var _a;
+  return Boolean((_a = line == null ? void 0 : line.metadata) == null ? void 0 : _a._giftInfo);
+}
 function buildCartView(lines, bookings) {
   const productLines = Array.isArray(lines) ? lines : [];
   const bookingList = Array.isArray(bookings) ? bookings : [];
   const linesByUid = indexProductsByUid(productLines);
   const claimedUids = /* @__PURE__ */ new Set();
-  const cartBookings = bookingList.filter((booking) => booking.parent_id !== 0).map((booking) => {
+  const cartBookings = bookingList.filter((booking) => booking.parent_id !== 0).reduce((acc, booking) => {
     const uid = booking == null ? void 0 : booking.product_uid;
     let product = null;
     if (uid !== void 0 && uid !== null && uid !== "") {
       const key = String(uid);
       if (!claimedUids.has(key)) {
         const line = linesByUid[key];
+        if (isGiftProductLine(line))
+          return acc;
         if (line) {
           claimedUids.add(key);
           product = line;
         }
       }
     }
-    return {
+    acc.push({
       ...booking,
       _extend: { product }
-    };
-  });
+    });
+    return acc;
+  }, []);
   const items = productLines.filter((line) => {
-    var _a, _b;
-    if ((_a = line.metadata) == null ? void 0 : _a._giftInfo)
+    var _a;
+    if (isGiftProductLine(line))
       return false;
-    const uid = (_b = line.metadata) == null ? void 0 : _b.unique_identification_number;
+    const uid = (_a = line.metadata) == null ? void 0 : _a.unique_identification_number;
     if (uid === void 0 || uid === null || uid === "")
       return true;
     return !claimedUids.has(String(uid));

package/lib/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/lib/solution/BookingTicket/utils/resolveBestAddTimePlan.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/BookingTicket/utils/resolveBestAddTimePlan.ts
+var resolveBestAddTimePlan_exports = {};
+__export(resolveBestAddTimePlan_exports, {
+  ADD_TIME_UNIT_MINUTES: () => ADD_TIME_UNIT_MINUTES,
+  buildAddTimeCandidates: () => buildAddTimeCandidates,
+  resolveBestAddTimePlan: () => resolveBestAddTimePlan
+});
+module.exports = __toCommonJS(resolveBestAddTimePlan_exports);
+var ADD_TIME_UNIT_MINUTES = [10, 15, 20, 30, 45, 60];
+var toPositiveNumber = (value) => {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : null;
+};
+var normalizeTargetMinutes = (minutes) => {
+  const n = Number(minutes);
+  return Number.isFinite(n) ? Math.max(0, Math.ceil(n)) : 0;
+};
+var gcd = (a, b) => {
+  let x = Math.abs(a);
+  let y = Math.abs(b);
+  while (y !== 0) {
+    const next = x % y;
+    x = y;
+    y = next;
+  }
+  return x;
+};
+var getDpStepMinutes = (candidates) => {
+  return candidates.reduce(
+    (current, candidate) => gcd(current, candidate.minutes),
+    0
+  ) || 1;
+};
+var comparePlans = (left, right) => {
+  if (!left)
+    return right;
+  if (right.totalPrice !== left.totalPrice) {
+    return right.totalPrice < left.totalPrice ? right : left;
+  }
+  const leftOverage = left.coveredMinutes - left.targetMinutes;
+  const rightOverage = right.coveredMinutes - right.targetMinutes;
+  if (rightOverage !== leftOverage) {
+    return rightOverage < leftOverage ? right : left;
+  }
+  return right.lines.length < left.lines.length ? right : left;
+};
+var toPlanLine = (candidate) => ({
+  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 = (candidates) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = `${candidate.productId}-${candidate.minutes}-${candidate.unlimited ? "u" : "n"}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.quantity += 1;
+      existing.totalPrice += candidate.totalPrice;
+      continue;
+    }
+    map.set(key, toPlanLine(candidate));
+  }
+  return Array.from(map.values());
+};
+var restoreDpCandidates = (dp, finiteCandidates, index) => {
+  const candidates = [];
+  let currentIndex = index;
+  while (currentIndex > 0) {
+    const current = dp[currentIndex];
+    if (!current || current.candidateIndex < 0)
+      break;
+    candidates.push(finiteCandidates[current.candidateIndex]);
+    currentIndex = current.prevIndex;
+  }
+  return candidates.reverse();
+};
+function buildAddTimeCandidates(products) {
+  const candidates = [];
+  for (const product of products) {
+    const price = toPositiveNumber(product.price);
+    if (price == null)
+      continue;
+    if (product.unlimited) {
+      candidates.push({
+        productId: product.id,
+        productTitle: product.title,
+        minutes: Number.POSITIVE_INFINITY,
+        unitPrice: price,
+        totalPrice: price,
+        unlimited: true
+      });
+      continue;
+    }
+    const minMinutes = toPositiveNumber(product.minMinutes);
+    if (minMinutes == null)
+      continue;
+    const maxMinutes = toPositiveNumber(product.maxMinutes) ?? minMinutes;
+    const unitMinutes = toPositiveNumber(product.unitMinutes) ?? minMinutes;
+    const safeMax = Math.max(minMinutes, maxMinutes);
+    for (let minutes = minMinutes; minutes <= safeMax; minutes += unitMinutes) {
+      candidates.push({
+        productId: product.id,
+        productTitle: product.title,
+        minutes,
+        unitPrice: price,
+        // 对齐旧版 addTimeModal：每个 unit_duration 切片收一次 price。例：60/10*10=$60。
+        totalPrice: minutes / unitMinutes * price
+      });
+    }
+  }
+  return candidates;
+}
+function resolveBestAddTimePlan(products, targetMinutes) {
+  const normalizedTarget = normalizeTargetMinutes(targetMinutes);
+  if (normalizedTarget <= 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: []
+    };
+  }
+  const candidates = buildAddTimeCandidates(products);
+  const finiteCandidates = candidates.filter(
+    (item) => Number.isFinite(item.minutes)
+  );
+  const unlimitedCandidates = candidates.filter((item) => item.unlimited);
+  const maxFiniteMinutes = Math.max(
+    0,
+    ...finiteCandidates.map((item) => item.minutes)
+  );
+  const searchLimit = normalizedTarget + maxFiniteMinutes;
+  let best = null;
+  for (const unlimited of unlimitedCandidates) {
+    best = comparePlans(best, {
+      available: true,
+      targetMinutes: normalizedTarget,
+      coveredMinutes: normalizedTarget,
+      totalPrice: unlimited.totalPrice,
+      lines: [toPlanLine({ ...unlimited, minutes: normalizedTarget })]
+    });
+  }
+  if (finiteCandidates.length && searchLimit > 0) {
+    const stepMinutes = getDpStepMinutes(finiteCandidates);
+    const searchLimitIndex = Math.ceil(searchLimit / stepMinutes);
+    const targetIndex = Math.ceil(normalizedTarget / stepMinutes);
+    const finiteCandidateSteps = finiteCandidates.map(
+      (candidate) => candidate.minutes / stepMinutes
+    );
+    const dp = [];
+    dp[0] = {
+      price: 0,
+      itemCount: 0,
+      prevIndex: -1,
+      candidateIndex: -1
+    };
+    for (let index = 0; index <= searchLimitIndex; index += 1) {
+      const current = dp[index];
+      if (!current)
+        continue;
+      for (let candidateIndex = 0; candidateIndex < finiteCandidates.length; candidateIndex += 1) {
+        const nextIndex = index + finiteCandidateSteps[candidateIndex];
+        if (nextIndex > searchLimitIndex)
+          continue;
+        const candidate = finiteCandidates[candidateIndex];
+        const nextPrice = current.price + candidate.totalPrice;
+        const nextItemCount = current.itemCount + 1;
+        const prev = dp[nextIndex];
+        if (!prev || nextPrice < prev.price || nextPrice === prev.price && nextItemCount < prev.itemCount) {
+          dp[nextIndex] = {
+            price: nextPrice,
+            itemCount: nextItemCount,
+            prevIndex: index,
+            candidateIndex
+          };
+        }
+      }
+    }
+    for (let index = targetIndex; index <= searchLimitIndex; index += 1) {
+      const current = dp[index];
+      if (!current)
+        continue;
+      const coveredMinutes = index * stepMinutes;
+      best = comparePlans(best, {
+        available: true,
+        targetMinutes: normalizedTarget,
+        coveredMinutes,
+        totalPrice: current.price,
+        lines: mergePlanLines(restoreDpCandidates(dp, finiteCandidates, index))
+      });
+    }
+  }
+  return best ?? {
+    available: false,
+    unavailableReason: "NO_COVERAGE",
+    targetMinutes: normalizedTarget,
+    coveredMinutes: 0,
+    totalPrice: 0,
+    lines: []
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADD_TIME_UNIT_MINUTES,
+  buildAddTimeCandidates,
+  resolveBestAddTimePlan
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "2.2.230",
+  "version": "2.2.231",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",