@pisell/pisellos 2.2.243 → 2.2.244

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

@@ -1,185 +0,0 @@
-/**
- * 计算指定加时时长下的最优购买方案。
- *
- * 输入的商品结构来自旧版 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 中会合并为一行：product_add_schedule_time=30，num=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;
-    _originalProduct?: unknown;
-}
-export interface AddTimePlanLine {
-    product_id: string | number;
-    product_title?: string;
-    product_add_schedule_time: number;
-    num: number;
-    price: number;
-    _originalProduct?: unknown;
-}
-export interface AddTimePlan {
-    available: boolean;
-    unavailableReason?: 'NO_PRODUCTS' | 'NO_COVERAGE';
-    targetMinutes: number;
-    coveredMinutes: number;
-    totalPrice: number;
-    lines: AddTimePlanLine[];
-}
-interface AddTimeCandidate extends AddTimePlanLine {
-    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

@@ -1,254 +0,0 @@
-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.product_add_schedule_time),
-    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) => ({
-  product_id: candidate.product_id,
-  product_title: candidate.product_title,
-  product_add_schedule_time: Number.isFinite(candidate.product_add_schedule_time) ? candidate.product_add_schedule_time : 0,
-  num: candidate.num,
-  price: candidate.price,
-  _originalProduct: candidate._originalProduct
-});
-var mergePlanLines = (candidates) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const key = `${candidate.product_id}-${candidate.product_add_schedule_time}-${candidate.unlimited ? "u" : "n"}`;
-    const existing = map.get(key);
-    if (existing) {
-      existing.num += candidate.num;
-      continue;
-    }
-    map.set(key, toPlanLine(candidate));
-  }
-  return Array.from(map.values());
-};
-var sumPlanLineMinutes = (lines) => lines.reduce(
-  (total, line) => total + line.product_add_schedule_time * line.num,
-  0
-);
-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({
-        product_id: product.id,
-        product_title: product.title,
-        _originalProduct: product._originalProduct ?? product,
-        product_add_schedule_time: Number.POSITIVE_INFINITY,
-        num: 1,
-        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({
-        product_id: product.id,
-        product_title: product.title,
-        _originalProduct: product._originalProduct ?? product,
-        product_add_schedule_time: minutes,
-        num: 1,
-        price,
-        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.product_add_schedule_time)
-  );
-  const unlimitedCandidates = candidates.filter((item) => item.unlimited);
-  const maxFiniteMinutes = Math.max(
-    0,
-    ...finiteCandidates.map((item) => item.product_add_schedule_time)
-  );
-  const searchLimit = normalizedTarget + maxFiniteMinutes;
-  let best = null;
-  for (const unlimited of unlimitedCandidates) {
-    const lines = [
-      toPlanLine({
-        ...unlimited,
-        product_add_schedule_time: normalizedTarget
-      })
-    ];
-    best = comparePlans(best, {
-      available: true,
-      targetMinutes: normalizedTarget,
-      coveredMinutes: sumPlanLineMinutes(lines),
-      totalPrice: unlimited.totalPrice,
-      lines
-    });
-  }
-  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.product_add_schedule_time / 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 lines = mergePlanLines(
-        restoreDpCandidates(dp, finiteCandidates, index)
-      );
-      best = comparePlans(best, {
-        available: true,
-        targetMinutes: normalizedTarget,
-        coveredMinutes: sumPlanLineMinutes(lines),
-        totalPrice: current.price,
-        lines
-      });
-    }
-  }
-  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/lib/solution/BookingTicket/utils/scan/applyGlobalScan.d.ts

@@ -1,36 +0,0 @@
-import type { GlobalScanHandleResult, GlobalScanHostBridge, ICustomer } from '../../types';
-import type { AddProductDecision } from '../addProductDecision';
-import { GlobalScanFormattedResult } from './formatGlobalScan';
-/** applyGlobalScan 所需的 BookingTicket 运行时能力 */
-export interface GlobalScanApplyHost {
-    setOrderCustomer(customer: ICustomer | null): void;
-    getOrderCustomerSnapshot(): ICustomer | null;
-    getBusinessCode(): string | undefined;
-    buildAddProductCtx(extra?: Record<string, any>): Record<string, any>;
-    decideAddProduct(item: any, options?: Record<string, any>): AddProductDecision;
-    decideAfterDetail(cacheItem: any, options?: Record<string, any>): AddProductDecision;
-    transformDetailToProductAndBooking(input: {
-        item: any;
-        cacheItem?: any;
-        detailResult?: {
-            e: any;
-            extension_type?: any;
-            detail?: any;
-        };
-        options?: Record<string, any>;
-    }): {
-        product: any;
-        booking?: any;
-        cacheItem: any;
-    };
-    addProductToOrder(product: any, booking?: any): Promise<any>;
-}
-/**
- * 应用全局扫码格式化结果：设客户 / 加车 / 开单 / 弹窗链。
- *
- * @example
- * ```ts
- * const result = await applyGlobalScan(bookingTicket, formatted, bridge);
- * ```
- */
-export declare function applyGlobalScan(host: GlobalScanApplyHost, formatted: GlobalScanFormattedResult, bridge?: GlobalScanHostBridge): Promise<GlobalScanHandleResult>;

package/lib/solution/BookingTicket/utils/scan/applyGlobalScan.js

@@ -1,168 +0,0 @@
-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/scan/applyGlobalScan.ts
-var applyGlobalScan_exports = {};
-__export(applyGlobalScan_exports, {
-  applyGlobalScan: () => applyGlobalScan
-});
-module.exports = __toCommonJS(applyGlobalScan_exports);
-var import_addProductDecision = require("../addProductDecision");
-var import_cartView = require("../cartView");
-var import_scanProductValues = require("./scanProductValues");
-async function processScannedProductItem(host, item, code, bridge) {
-  const ctx = host.buildAddProductCtx();
-  if ((0, import_scanProductValues.isScanProductBundle)(item) || (0, import_scanProductValues.isScanProductOption)(item)) {
-    return runRequiresDetailFlow(host, item, ctx, bridge);
-  }
-  if ((0, import_scanProductValues.countScanVariantMatches)(item, code) >= 2) {
-    return runRequiresDetailFlow(host, item, ctx, bridge);
-  }
-  const values = (0, import_scanProductValues.genScanProductValues)(item, code);
-  const itemWithSelection = { ...item, cartDetailValue: values };
-  const decision = host.decideAddProduct(itemWithSelection, ctx);
-  return runAddProductDecision(host, item, decision, ctx, bridge);
-}
-async function runRequiresDetailFlow(host, item, ctx, bridge) {
-  if (!(bridge == null ? void 0 : bridge.openProductDetail)) {
-    return "pending";
-  }
-  const payload = (0, import_addProductDecision.buildRequiresDetailPayload)(item, ctx);
-  const detailResult = await bridge.openProductDetail(payload);
-  if (!detailResult) {
-    return "cancelled";
-  }
-  if (!bridge.confirmDetail) {
-    return "pending";
-  }
-  await bridge.confirmDetail({
-    item: payload.productData ?? payload.item ?? item,
-    detailResult
-  });
-  return "added";
-}
-async function runAddProductDecision(host, catalogItem, decision, ctx, bridge) {
-  if (decision.action === "reloadCatalog") {
-    return "cancelled";
-  }
-  if (decision.action === "add") {
-    const transformed = host.transformDetailToProductAndBooking({
-      item: catalogItem,
-      cacheItem: decision.cacheItem,
-      options: ctx
-    });
-    await host.addProductToOrder(transformed.product, transformed.booking);
-    return "added";
-  }
-  if (decision.action === "requiresDetail") {
-    return runRequiresDetailFlow(host, catalogItem, ctx, bridge);
-  }
-  if (decision.action === "requiresBookingEdit") {
-    if (!(bridge == null ? void 0 : bridge.openBookingEdit)) {
-      return "pending";
-    }
-    const edited = await bridge.openBookingEdit(decision.payload);
-    if (!edited) {
-      return "cancelled";
-    }
-    if (!bridge.confirmBookingEdit) {
-      return "pending";
-    }
-    await bridge.confirmBookingEdit({ cacheItem: edited });
-    return "added";
-  }
-  return "pending";
-}
-async function applyGlobalScan(host, formatted, bridge) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const { searchType, data, scanCode } = formatted;
-  if (searchType === "wallet") {
-    if (!data) {
-      (_a = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _a.call(bridge, "fail", "pisell2.text.scan-global-failed");
-      return { status: "failed", reason: "invalid_data" };
-    }
-    host.setOrderCustomer(data);
-    (_b = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _b.call(bridge, "success", "pisell2.text.add-client-success");
-    return { status: "success", kind: "customer" };
-  }
-  if (searchType === "walletPass") {
-    if (!data) {
-      (_c = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _c.call(bridge, "fail", "pisell2.text.scan-global-failed");
-      return { status: "failed", reason: "invalid_data" };
-    }
-    const snapshot = host.getOrderCustomerSnapshot();
-    if ((0, import_cartView.isWalkInCustomer)(snapshot)) {
-      if (!(bridge == null ? void 0 : bridge.applyPromotionCode)) {
-        return { status: "failed", reason: "no_bridge" };
-      }
-      const result = await bridge.applyPromotionCode(scanCode);
-      if (result == null ? void 0 : result.isAvailable) {
-        return { status: "success", kind: "promotion" };
-      }
-      return { status: "failed", reason: "invalid_data" };
-    }
-    host.setOrderCustomer(data);
-    (_d = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _d.call(bridge, "success", "pisell2.text.add-client-success");
-    return { status: "success", kind: "customer" };
-  }
-  if (searchType === "product" || searchType === "local_product") {
-    const list = data == null ? void 0 : data.list;
-    if (!Array.isArray(list) || list.length === 0) {
-      (_e = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _e.call(bridge, "fail", "pisell2.text.scan-global-failed");
-      return { status: "failed", reason: "invalid_data" };
-    }
-    let addedCount = 0;
-    for (const item of list) {
-      const outcome = await processScannedProductItem(host, item, scanCode, bridge);
-      if (outcome === "added") {
-        addedCount += 1;
-      }
-      if (outcome === "cancelled") {
-        return { status: "cancelled" };
-      }
-      if (outcome === "pending") {
-        return { status: "pending", kind: "requiresDetail" };
-      }
-    }
-    if (addedCount > 0) {
-      (_f = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _f.call(bridge, "success");
-      return { status: "success", kind: "products", meta: { count: addedCount } };
-    }
-    return { status: "failed", reason: "no_bridge" };
-  }
-  if (searchType === "order") {
-    const orderId = (data == null ? void 0 : data.order_id) ?? (data == null ? void 0 : data.id);
-    if (!orderId) {
-      (_g = bridge == null ? void 0 : bridge.onNotify) == null ? void 0 : _g.call(bridge, "fail", "pisell2.text.scan-global-failed");
-      return { status: "failed", reason: "invalid_data" };
-    }
-    if (!(bridge == null ? void 0 : bridge.openOrder)) {
-      return { status: "pending", kind: "openOrder" };
-    }
-    bridge.openOrder({
-      order_id: Number(orderId),
-      business_code: (data == null ? void 0 : data.business_code) ?? host.getBusinessCode()
-    });
-    return { status: "pending", kind: "openOrder" };
-  }
-  return { status: "failed", reason: "invalid_data" };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyGlobalScan
-});

package/lib/solution/BookingTicket/utils/scan/formatGlobalScan.d.ts

@@ -1,32 +0,0 @@
-/**
- * 全局扫码搜索结果格式化（对齐 ticketBooking `formatScanGlobal`）。
- */
-export type GlobalScanSearchType = 'customer' | 'wallet' | 'walletPass' | 'product' | 'local_product' | 'order';
-export interface GlobalScanFormattedResult {
-    searchType: GlobalScanSearchType;
-    data: any;
-    scanCode: string;
-}
-interface RawScanSearchResult {
-    searchType?: GlobalScanSearchType;
-    response?: {
-        status?: boolean;
-        code?: number;
-        message?: string;
-        data?: any;
-    };
-}
-/**
- * 将 handleGlobalScan 返回的原始结构格式化为 UI/OS 统一结构。
- *
- * @example
- * ```ts
- * const formatted = formatGlobalScanResult(
- *   { searchType: 'wallet', response: { code: 200, data: { customer: {...} } } },
- *   'WL123',
- * );
- * // => { searchType: 'wallet', data: customerObj, scanCode: 'WL123' }
- * ```
- */
-export declare function formatGlobalScanResult(raw: RawScanSearchResult | null | undefined, scanCode: string): GlobalScanFormattedResult | null;
-export {};