@pisell/pisellos 0.0.568 → 0.0.570

package/lib/modules/Order/utils/orderCollectionIdentity.js

@@ -0,0 +1,353 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyOrderCollectionUidRemaps = applyOrderCollectionUidRemaps;
+exports.buildOrderCollectionFallbackUid = buildOrderCollectionFallbackUid;
+exports.createUuidV4 = createUuidV4;
+exports.getOrderCollectionPersistentId = getOrderCollectionPersistentId;
+exports.getOrderCollectionReferenceUid = getOrderCollectionReferenceUid;
+exports.getOrderCollectionUid = getOrderCollectionUid;
+exports.isBlankOrderCollectionIdentity = isBlankOrderCollectionIdentity;
+exports.isSameOrderCollectionItem = isSameOrderCollectionItem;
+exports.mergeOrderCollectionItems = mergeOrderCollectionItems;
+exports.normalizeOrderCollection = normalizeOrderCollection;
+exports.normalizeOrderCollections = normalizeOrderCollections;
+exports.setOrderCollectionUid = setOrderCollectionUid;
+var _lodashEs = require("lodash-es");
+const IDENTITY_CONFIG = {
+  product: {
+    persistentIdField: 'order_detail_id',
+    uidField: 'unique_identification_number',
+    fallbackPrefix: 'os-fallback:product:order-detail'
+  },
+  booking: {
+    persistentIdField: 'schedule_event_id',
+    uidField: 'unique_identification_number',
+    fallbackPrefix: 'os-fallback:booking:schedule-event'
+  },
+  payment: {
+    persistentIdField: 'order_payment_id',
+    uidField: 'unique_payment_number',
+    fallbackPrefix: 'os-fallback:payment:order-payment'
+  }
+};
+function createUuidV4() {
+  const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  return template.replace(/[xy]/g, char => {
+    const randomValue = Math.floor(Math.random() * 16);
+    const value = char === 'x' ? randomValue : randomValue & 0x3 | 0x8;
+    return value.toString(16);
+  });
+}
+function isBlankOrderCollectionIdentity(value) {
+  return value === undefined || value === null || value === '';
+}
+function getOrderCollectionPersistentId(kind, item) {
+  const record = item;
+  if (!record) return null;
+  const value = record[IDENTITY_CONFIG[kind].persistentIdField];
+  if (isBlankOrderCollectionIdentity(value)) return null;
+  return String(value);
+}
+function getOrderCollectionUid(kind, item) {
+  const record = item;
+  if (!record) return null;
+  const uidField = IDENTITY_CONFIG[kind].uidField;
+  const metadataValue = record.metadata?.[uidField];
+  if (!isBlankOrderCollectionIdentity(metadataValue)) return String(metadataValue);
+  const topLevelValue = record[uidField];
+  if (isBlankOrderCollectionIdentity(topLevelValue)) return null;
+  return String(topLevelValue);
+}
+function buildOrderCollectionFallbackUid(kind, persistentId) {
+  return `${IDENTITY_CONFIG[kind].fallbackPrefix}:${String(persistentId)}`;
+}
+function getOrderCollectionReferenceUid(kind, item) {
+  const uid = getOrderCollectionUid(kind, item);
+  if (uid) return uid;
+  const persistentId = getOrderCollectionPersistentId(kind, item);
+  return persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : null;
+}
+function setOrderCollectionUid(kind, item, uid) {
+  const record = (0, _lodashEs.cloneDeep)(item || {});
+  const uidField = IDENTITY_CONFIG[kind].uidField;
+  record.metadata = {
+    ...(record.metadata && typeof record.metadata === 'object' ? record.metadata : {}),
+    [uidField]: uid
+  };
+  delete record[uidField];
+  return record;
+}
+
+/**
+ * 持久化行 ID 是服务端事实主键；只有至少一侧尚未持久化时，才允许用 runtime UID 对齐。
+ */
+function isSameOrderCollectionItem(kind, left, right) {
+  const leftPersistentId = getOrderCollectionPersistentId(kind, left);
+  const rightPersistentId = getOrderCollectionPersistentId(kind, right);
+  if (leftPersistentId && rightPersistentId) {
+    return leftPersistentId === rightPersistentId;
+  }
+  const leftUid = getOrderCollectionUid(kind, left);
+  const rightUid = getOrderCollectionUid(kind, right);
+  return Boolean(leftUid && rightUid && leftUid === rightUid);
+}
+function mergeOrderCollectionItems(kind, currentItem, incomingItem, options) {
+  const current = (0, _lodashEs.cloneDeep)(currentItem || {});
+  const incoming = (0, _lodashEs.cloneDeep)(incomingItem || {});
+  const persistentIdField = IDENTITY_CONFIG[kind].persistentIdField;
+  const currentPersistentIdValue = current[persistentIdField];
+  const incomingPersistentIdValue = incoming[persistentIdField];
+  const incomingUid = getOrderCollectionUid(kind, incoming);
+  const currentUid = getOrderCollectionUid(kind, current);
+  const persistentId = getOrderCollectionPersistentId(kind, incoming) || getOrderCollectionPersistentId(kind, current);
+  const merged = {
+    ...current,
+    ...incoming,
+    metadata: {
+      ...(current.metadata && typeof current.metadata === 'object' ? current.metadata : {}),
+      ...(incoming.metadata && typeof incoming.metadata === 'object' ? incoming.metadata : {})
+    }
+  };
+
+  // UID 对齐允许一侧尚未持久化，但稀疏 incoming 的 null/空值不能擦掉已存在行 ID。
+  if (!isBlankOrderCollectionIdentity(incomingPersistentIdValue)) {
+    merged[persistentIdField] = incomingPersistentIdValue;
+  } else if (!isBlankOrderCollectionIdentity(currentPersistentIdValue)) {
+    merged[persistentIdField] = currentPersistentIdValue;
+  }
+  const incomingUidIsDerived = Boolean(incomingUid && persistentId && (incomingUid === buildOrderCollectionFallbackUid(kind, persistentId) || incomingUid.startsWith(`${buildOrderCollectionFallbackUid(kind, persistentId)}:conflict:`)));
+  const uid = (incomingUid && !incomingUidIsDerived ? incomingUid : null) || currentUid || incomingUid || (options?.ensureUid === false ? null : persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : options?.createAnonymousUid?.() || createUuidV4());
+  return uid ? setOrderCollectionUid(kind, merged, uid) : merged;
+}
+function createEmptyIdentityStats() {
+  return {
+    backfilledUidCount: 0,
+    collapsedDuplicateCount: 0,
+    uidConflictCount: 0,
+    anonymousRowCount: 0
+  };
+}
+function allocateAnonymousUid(occupiedUids, createAnonymousUid) {
+  let uid = createAnonymousUid();
+  while (occupiedUids.has(uid)) uid = createAnonymousUid();
+  return uid;
+}
+function allocatePersistentConflictUid(kind, persistentId, occupiedUids) {
+  const fallbackUid = buildOrderCollectionFallbackUid(kind, persistentId);
+  if (!occupiedUids.has(fallbackUid)) return fallbackUid;
+
+  // 极端情况下其它行可能把本行 fallback 当作显式 UID 使用；继续派生稳定后缀，
+  // 避免修复冲突后仍留下重复 UID。规范化结果一旦持久化，后续读取保持幂等。
+  let suffix = 1;
+  let candidate = `${fallbackUid}:conflict:${suffix}`;
+  while (occupiedUids.has(candidate)) {
+    suffix += 1;
+    candidate = `${fallbackUid}:conflict:${suffix}`;
+  }
+  return candidate;
+}
+
+/**
+ * 规范化单一数组：强身份重复时保留首次位置、用最后一条业务字段覆盖，并统一补 UID。
+ */
+function normalizeOrderCollection(kind, items, options) {
+  const stats = createEmptyIdentityStats();
+  const uidRemaps = [];
+  const result = [];
+  const ensureUid = options?.ensureUid !== false;
+  const createAnonymousUid = options?.createAnonymousUid || createUuidV4;
+  for (const rawItem of items || []) {
+    const item = (0, _lodashEs.cloneDeep)(rawItem);
+    const existingIndex = result.findIndex(existing => isSameOrderCollectionItem(kind, existing, item));
+    if (existingIndex === -1) {
+      result.push(item);
+      continue;
+    }
+    const previousReferenceUid = getOrderCollectionReferenceUid(kind, result[existingIndex]);
+    const incomingReferenceUid = getOrderCollectionReferenceUid(kind, item);
+    result[existingIndex] = mergeOrderCollectionItems(kind, result[existingIndex], item, {
+      ensureUid: false
+    });
+    const nextUid = getOrderCollectionUid(kind, result[existingIndex]);
+    if (nextUid) {
+      for (const from of new Set([previousReferenceUid, incomingReferenceUid])) {
+        if (!from || from === nextUid) continue;
+        uidRemaps.push({
+          kind,
+          from,
+          to: nextUid,
+          persistentId: getOrderCollectionPersistentId(kind, result[existingIndex])
+        });
+      }
+    }
+    stats.collapsedDuplicateCount += 1;
+  }
+  if (!ensureUid) return {
+    items: result,
+    stats,
+    uidRemaps
+  };
+  const occupiedUids = new Set();
+  for (let index = 0; index < result.length; index += 1) {
+    let item = result[index];
+    const persistentId = getOrderCollectionPersistentId(kind, item);
+    let uid = getOrderCollectionUid(kind, item);
+    if (!uid) {
+      uid = persistentId ? buildOrderCollectionFallbackUid(kind, persistentId) : allocateAnonymousUid(occupiedUids, createAnonymousUid);
+      item = setOrderCollectionUid(kind, item, uid);
+      result[index] = item;
+      stats.backfilledUidCount += 1;
+      if (!persistentId) stats.anonymousRowCount += 1;
+    }
+    if (occupiedUids.has(uid)) {
+      const replacementUid = persistentId ? allocatePersistentConflictUid(kind, persistentId, occupiedUids) : allocateAnonymousUid(occupiedUids, createAnonymousUid);
+      result[index] = setOrderCollectionUid(kind, item, replacementUid);
+      uidRemaps.push({
+        kind,
+        from: uid,
+        to: replacementUid,
+        persistentId,
+        scope: 'linked-owner',
+        referenceOwnerUid: kind === 'product' ? String(item?.booking_uid || item?.metadata?.booking_uid || '') || null : kind === 'booking' ? String(item?.product_uid || item?.metadata?.product_uid || '') || null : null
+      });
+      uid = replacementUid;
+      stats.uidConflictCount += 1;
+    }
+    occupiedUids.add(uid);
+  }
+  return {
+    items: result,
+    stats,
+    uidRemaps
+  };
+}
+function applyOrderCollectionUidRemaps(sourceOrder, uidRemaps) {
+  if (!uidRemaps.length) return sourceOrder;
+  const order = (0, _lodashEs.cloneDeep)(sourceOrder);
+  const hasAmbiguousLinkedOwner = remap => {
+    if (remap.scope !== 'linked-owner' || !remap.referenceOwnerUid) return false;
+    const ownerKind = remap.kind === 'product' ? 'booking' : remap.kind === 'booking' ? 'product' : null;
+    if (!ownerKind) return false;
+    return uidRemaps.some(candidate => candidate.scope === 'linked-owner' && candidate.kind === ownerKind && candidate.from === remap.referenceOwnerUid);
+  };
+  for (const remap of uidRemaps) {
+    if (remap.from === remap.to) continue;
+    const linkedOwnerIsAmbiguous = hasAmbiguousLinkedOwner(remap);
+    if (remap.kind === 'product') {
+      for (const booking of order.bookings || []) {
+        if (remap.scope === 'linked-owner' && (linkedOwnerIsAmbiguous || getOrderCollectionUid('booking', booking) !== remap.referenceOwnerUid)) {
+          continue;
+        }
+        if (String(booking?.product_uid || '') === remap.from) {
+          booking.product_uid = remap.to;
+        }
+        if (String(booking?.metadata?.product_uid || '') === remap.from) {
+          booking.metadata = {
+            ...(booking.metadata || {}),
+            product_uid: remap.to
+          };
+        }
+      }
+      // 冲突 UID 仍由第一条持有；赠品父引用缺少可用的持久化行定位时不能全局改写。
+      if (remap.scope !== 'linked-owner') {
+        for (const product of order.products || []) {
+          if (String(product?.metadata?.parent_unique_identification_number || '') === remap.from) {
+            product.metadata = {
+              ...(product.metadata || {}),
+              parent_unique_identification_number: remap.to
+            };
+          }
+          const giftInfo = product?.metadata?._giftInfo;
+          if (giftInfo && typeof giftInfo === 'object') {
+            const sourceProductIds = Array.isArray(giftInfo.sourceProductIds) ? giftInfo.sourceProductIds.map(uid => String(uid) === remap.from ? remap.to : uid) : giftInfo.sourceProductIds;
+            const sourceProductId = String(giftInfo.sourceProductId || '') === remap.from ? remap.to : giftInfo.sourceProductId;
+            product.metadata = {
+              ...(product.metadata || {}),
+              _giftInfo: {
+                ...giftInfo,
+                ...(sourceProductIds !== undefined ? {
+                  sourceProductIds
+                } : {}),
+                ...(sourceProductId !== undefined ? {
+                  sourceProductId
+                } : {})
+              }
+            };
+          }
+        }
+      }
+      const productsByUid = order._extend?.productsByUid;
+      const cachedProduct = productsByUid?.[remap.from];
+      const cachedPersistentId = getOrderCollectionPersistentId('product', cachedProduct?.origin || cachedProduct);
+      if (productsByUid && remap.scope === 'linked-owner') {
+        const retainedProduct = (order.products || []).find(product => getOrderCollectionUid('product', product) === remap.from);
+        const remappedProduct = (order.products || []).find(product => getOrderCollectionUid('product', product) === remap.to);
+        if (cachedProduct && remap.persistentId && cachedPersistentId === remap.persistentId) {
+          productsByUid[remap.to] = {
+            ...(cachedProduct || {}),
+            ...(productsByUid[remap.to] || {})
+          };
+          if (retainedProduct) {
+            productsByUid[remap.from] = {
+              ...(cachedProduct || {}),
+              origin: (0, _lodashEs.cloneDeep)(retainedProduct)
+            };
+          }
+        } else if (remappedProduct && !productsByUid[remap.to]) {
+          productsByUid[remap.to] = {
+            origin: (0, _lodashEs.cloneDeep)(remappedProduct)
+          };
+        }
+        continue;
+      }
+      if (cachedProduct && remap.scope !== 'linked-owner') {
+        productsByUid[remap.to] = {
+          ...(cachedProduct || {}),
+          ...(productsByUid[remap.to] || {})
+        };
+        delete productsByUid[remap.from];
+      }
+    }
+    if (remap.kind === 'booking') {
+      for (const product of order.products || []) {
+        if (remap.scope === 'linked-owner' && (linkedOwnerIsAmbiguous || getOrderCollectionUid('product', product) !== remap.referenceOwnerUid)) {
+          continue;
+        }
+        if (String(product?.booking_uid || '') === remap.from) {
+          product.booking_uid = remap.to;
+        }
+        if (String(product?.metadata?.booking_uid || '') === remap.from) {
+          product.metadata = {
+            ...(product.metadata || {}),
+            booking_uid: remap.to
+          };
+        }
+      }
+    }
+  }
+  return order;
+}
+function normalizeOrderCollections(sourceOrder, options) {
+  let order = (0, _lodashEs.cloneDeep)(sourceOrder || {});
+  const orderRecord = order;
+  const productResult = normalizeOrderCollection('product', Array.isArray(orderRecord.products) ? orderRecord.products : [], options);
+  const bookingResult = normalizeOrderCollection('booking', Array.isArray(orderRecord.bookings) ? orderRecord.bookings : [], options);
+  const paymentResult = normalizeOrderCollection('payment', Array.isArray(orderRecord.payments) ? orderRecord.payments : [], options);
+  if (Array.isArray(orderRecord.products)) orderRecord.products = productResult.items;
+  if (Array.isArray(orderRecord.bookings)) orderRecord.bookings = bookingResult.items;
+  if (Array.isArray(orderRecord.payments)) orderRecord.payments = paymentResult.items;
+  const uidRemaps = [...productResult.uidRemaps, ...bookingResult.uidRemaps, ...paymentResult.uidRemaps];
+  order = applyOrderCollectionUidRemaps(order, uidRemaps);
+  return {
+    order,
+    stats: {
+      product: productResult.stats,
+      booking: bookingResult.stats,
+      payment: paymentResult.stats
+    },
+    uidRemaps
+  };
+}

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

@@ -1,7 +1,20 @@
 import Decimal from 'decimal.js';
-import { CartItem } from "../Cart";
-import type { ScanOrderSubmitPayload, ScanOrderSubmitProduct, ScanOrderSummary, ScanOrderTempOrder } from '../../solution/ScanOrder/types';
+import type { CartItem } from "../Cart";
+import type { OrderProductDiscountItem, OrderProduct, OrderSubmitPayload, OrderSubmitProduct, OrderSummary, OrderTempOrder } from './types';
 import type { RulesParamsHooks } from '../Rules/types';
+import type { MapOrderPaymentsOptions, OrderPaymentData, OrderPaymentSource } from './types';
+import { createUuidV4 } from './utils/orderCollectionIdentity';
+export interface OrderProductsDepositProtocol {
+    id: number;
+    title: string;
+}
+export interface OrderProductsDepositSummary {
+    total: number;
+    totalText: string;
+    protocols: OrderProductsDepositProtocol[];
+    deposit_policy_ids: number[];
+    hasDeposit: boolean;
+}
 import type { WindowPlugin } from '../../plugins';
 /**
  * 把"含 option 的主商品单价"与 bundle 合成"单行 composite 单价"。
@@ -21,21 +34,68 @@ export declare function composeLinePrice(params: {
     bundle?: Array<{
         bundle_selling_price?: any;
         price?: any;
+        custom_price?: any;
         num?: any;
         quantity?: any;
         original_price?: any;
         product_price?: any;
+        price_type?: any;
+        price_type_ext?: any;
+        custom_price_type?: any;
+        custom_price_type_ext?: any;
+        option?: Array<{
+            add_price?: any;
+            price?: any;
+            num?: any;
+        }>;
     }> | null;
     useOriginalBundle?: boolean;
 }): string;
+export declare function normalizeProductSkuOptions(options?: unknown): Record<string, any>[];
+export declare function ensureProductSku(product?: Record<string, any> | null): Record<string, any> & {
+    option: Record<string, any>[];
+};
+export declare function getProductSkuOptions(product?: Record<string, any> | null): Record<string, any>[];
 /**
- * 计算 option 单价合计：Σ(option.price × option.num)。
+ * 计算 option 单价合计：Σ(option.add_price × option.num)。
+ * 兼容入参仍带旧 `price` 的调用方，但运行时归一化后只维护 `add_price`。
  * 在新语义 v2 下，main_product_original_price = source_product_price + 本函数结果。
  */
 export declare function sumOptionUnitPrice(options?: Array<{
+    add_price?: any;
     price?: any;
     num?: any;
 }> | null): Decimal;
+/**
+ * 仅基于 tempOrder.products 重算整单定金。
+ *
+ * 商品折扣在进入定金计算前已体现在商品行价格字段中，
+ * 因此这里只按商品定金规则汇总，不再扣减 discount_list；tempOrder.bookings 不参与这里的计算。
+ */
+export declare function calculateOrderProductsDeposit(products?: OrderProduct[], options?: {
+    productsByUid?: Record<string, Record<string, any>>;
+}): OrderProductsDepositSummary;
+/**
+ * 判定套餐子商品是否为 markdown（减价）类型。
+ * 与后端口径一致：price_type='markdown' 且 price_type_ext 非 'product_price'（原价子商品）。
+ */
+export declare function isMarkdownBundle(bundle: Record<string, any> | null | undefined): boolean;
+/**
+ * 套餐子商品对「行价」的带符号单位贡献（与后端 markdown 口径对齐）。
+ *
+ * - markdown（减价）：净额 = |catalog 毛价| − Σ(option.add_price×num)，**取负**（行内减）。
+ *   catalog 毛价优先 `price`/`custom_price`（避免读已落净额的 `bundle_selling_price` 造成 option 二次扣减）；
+ *   仅当毛价缺失（历史/hydrate 仅剩净额）时退回 `bundle_selling_price`，且此时不再扣 option。
+ * - markup（加价）/原价子商品：维持 `+(bundle_selling_price ?? price)`，行为不变。
+ */
+export declare function getBundleSignedUnit(bundle: Record<string, any> | null | undefined, options?: {
+    useOriginal?: boolean;
+}): Decimal;
+/**
+ * 套餐子商品 `bundle_selling_price` 的存储净额（正值幅度）。
+ * markdown 取净额绝对值（3.70）；markup/原价维持原值。
+ */
+export declare function getBundleSellingMagnitude(bundle: Record<string, any> | null | undefined): Decimal;
 /**
  * OrderModule 默认 Rules 钩子工厂。
  *
@@ -48,7 +108,7 @@ export declare function sumOptionUnitPrice(options?: Array<{
  *   不含折扣。**权威源**。
  * - `metadata.main_product_original_price` = source + Σ(option.price × option.num)（含 option、不含折扣）。
  * - `metadata.main_product_selling_price` = main_original − 主商品券 per-unit amount（含 option、含折扣）。
- * - `payment_price`：出站 payload 中由 `selling_price` 派生以兼容后端（composite）。
+ * - `payment_price`：出站 payload 中为行 composite 已减整单折扣均摊价（无折扣时与 `selling_price` 同义）。
  *
  * Rules 钩子契约（hook_adapt 方案，Rules 内部保持不变）：
  * - `getProduct.price` / `getProduct.original_price` 回传 **source-level 主价**
@@ -65,6 +125,37 @@ export declare function sumOptionUnitPrice(options?: Array<{
  *
  * 导出为纯函数方便单测直接驱动钩子，不依赖 OrderModule 实例。
  */
+/** Rules calcDiscount 用手动价标记；undefined 表示交给 Rules 用 total/origin_total 推断 */
+export declare function resolveRulesManualDiscountFlag(metadata: Record<string, any> | null | undefined): boolean | undefined;
+/**
+ * 商品行折扣只保留后端 OrderProductDiscountItem 协议字段。
+ * Rules/券计算过程中的 `_num`、`config` 等运行态字段不应进入 tempOrder 或提交 payload。
+ */
+export declare function normalizeOrderProductDiscountList(discountList?: unknown[] | null): OrderProductDiscountItem[];
+/**
+ * 手动改价（price_override）时行级 original_price（composite 单价）：
+ * 购物车划线价应对齐 metadata.origin._extend.origin_total（改价前单价 composite，如 40），
+ * 而非 bundle 子项 catalog 原价合成的 composedOriginalPrice（如 30）。
+ *
+ * origin_total 与 SkuDetailModal / cacheItem._extend 一致，为单价语义，不再除以 num。
+ */
+export declare function resolveManualOverrideLineOriginalPrice(params: {
+    num?: number;
+    metadata?: Record<string, any> | null;
+    /** 已有行级 original_price（origin 被裁剪时兜底划线价） */
+    lineOriginalPrice?: string | number | null;
+}, fallbackCompositeOriginal: string): string;
+/**
+ * 计算商品行「每单位有效折扣」：discount_list 合计 + 被 Rules 剥离但仍 inPromotion 的差额。
+ *
+ * Rules.calcDiscount 会把 type=promotion 从 discount_list 去掉，但 metadata._promotion 仍保留；
+ * applyProductDiscountPrices 必须回读 _promotion，否则抬价/降价都会在第二步被 source 原价覆盖。
+ *
+ * @example
+ * resolveEffectivePerUnitDiscount({ metadata: { _promotion: { inPromotion: true, originalPrice: 1, finalPrice: 5 } }, discount_list: [] });
+ * // => -4
+ */
+export declare function resolveEffectivePerUnitDiscount(product: Record<string, any>): number;
 export declare function createDefaultOrderRulesHooks(): RulesParamsHooks;
 /**
  * 通过 session 类商品的开始时间结束时间生成商品的时长
@@ -97,46 +188,49 @@ export interface CartOrderHolder {
  */
 export declare function ensureCartItemOriginHolder(cartItem: CartItem, window?: WindowPlugin): void;
 export declare const getAllDiscountList: (cartItem: CartItem) => any;
-export declare function createUuidV4(): string;
-export declare function isTempOrder(data: any): data is ScanOrderTempOrder;
+export { createUuidV4 };
+export declare function isTempOrder(data: any): data is OrderTempOrder;
 export declare function formatDateTime(date: Date): string;
+export declare function normalizeBookingIsAll(booking: Record<string, any>): 0 | 1;
+export declare function normalizeBookingSubType(booking: Record<string, any>): 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 resolveSubmitCollectPax(tempOrder: OrderTempOrder): number;
 export declare function createDefaultTempOrder(params: {
     now: string;
-    summary?: ScanOrderSummary;
-}): ScanOrderTempOrder;
+    summary?: OrderSummary;
+}): OrderTempOrder;
 export interface SubmitPayloadEnhancerContext {
-    tempOrder: ScanOrderTempOrder;
+    tempOrder: OrderTempOrder;
     bookingUuid: string;
     now: Date;
 }
-export type SubmitPayloadEnhancer = (payload: ScanOrderSubmitPayload, ctx: SubmitPayloadEnhancerContext) => ScanOrderSubmitPayload;
+export declare type SubmitPayloadEnhancer = (payload: OrderSubmitPayload, ctx: SubmitPayloadEnhancerContext) => OrderSubmitPayload;
 export declare function buildSubmitPayload(params: {
-    tempOrder: ScanOrderTempOrder;
+    tempOrder: OrderTempOrder;
     cacheId?: string;
     now?: Date;
     platform?: string;
     businessCode?: string;
     channel?: string;
     type?: string;
+    summary?: OrderSummary | null;
+    request_unique_idempotency_token?: string;
     enhance?: SubmitPayloadEnhancer;
-}): ScanOrderSubmitPayload;
-/** 加单（scanOrderMore）不应提交 booking 关联的虚拟规则商品行 */
-export declare function filterProductsForScanOrderMore(products: ScanOrderSubmitProduct[]): ScanOrderSubmitProduct[];
+}): OrderSubmitPayload;
+export declare function mapPaymentItemToOrderPayment(paymentItem: OrderPaymentSource): OrderPaymentData;
+export declare function mapPaymentItemsToOrderPayments(paymentItems: OrderPaymentSource[], options?: MapOrderPaymentsOptions): OrderPaymentData[];
 /**
  * 历史 V1 加餐结构映射器。
  *
- * @deprecated 加餐（`PUT /order/order/product/:id`）已改为与正常 checkout 共用
- * `ScanOrderSubmitProduct` 新结构（见 `OrderModule.submitTempOrder` 的加餐分支）。
+ * @deprecated 标准 Sales checkout 已统一提交结构。
  * 本函数仅保留以兼容历史接入方，未来会移除。新代码请勿再调用。
  */
-export declare function formatV1Product(products: ScanOrderSubmitProduct[]): {
+export declare function formatV1Product(products: OrderSubmitProduct[]): {
     bundle: any[];
     key: number | null;
     option: any[];
@@ -148,4 +242,59 @@ export declare function formatV1Product(products: ScanOrderSubmitProduct[]): {
     session: null;
     unique: string;
 }[];
+/**
+ * 判断 holder_id 是否已分配（非空）。
+ *
+ * @example
+ * hasAssignedHolderId(12); // true
+ * hasAssignedHolderId([]); // false
+ */
+export declare function hasAssignedHolderId(value: unknown): boolean;
+/**
+ * 清空 tempOrder 购物车行上的 holder 分配（products / bookings / runtime origin）。
+ * 移除或更换下单客户时调用，与 booking 页换客户清 holder 行为对齐。
+ *
+ * @example
+ * clearTempOrderHolderAssignments(tempOrder);
+ */
+export declare function clearTempOrderHolderAssignments(tempOrder: OrderTempOrder): boolean;
+/**
+ * 读取购物车行的 stable uid（优先 metadata.unique_identification_number）。
+ *
+ * @example
+ * getOrderProductLineUid({ metadata: { unique_identification_number: 'line-1' } }); // 'line-1'
+ */
+export declare function getOrderProductLineUid(product: Record<string, any> | null | undefined): string | null;
+export declare function getRuntimeProductOrigin(tempOrder: OrderTempOrder | null | undefined, product: any): Record<string, any> | null;
+export declare function isHolderConfigRequired(holderConfig: any): boolean;
+export declare function productRequiresFormSubject(tempOrder: OrderTempOrder | null | undefined, product: any): boolean;
+export declare function resolveIsFormSubject(tempOrder: OrderTempOrder | null | undefined, product?: any): boolean;
+/**
+ * 判断展示字段是否为空（含 i18n 对象全空）。
+ *
+ * @example
+ * isEmptyOrderProductDisplayValue(''); // true
+ * isEmptyOrderProductDisplayValue({ auto: '桌台费' }); // false
+ */
+export declare function isEmptyOrderProductDisplayValue(value: unknown): boolean;
+/**
+ * calcDiscount / applyDiscount 回写时 Rules 往往不带 product_title 等展示字段；
+ * 用旧行补齐，避免编辑态 hydrate 后标题被冲掉。
+ *
+ * @example
+ * mergeOrderProductDisplayFields(
+ *   { product_title: { auto: '桌台费' }, metadata: { unique_identification_number: 'u1' } },
+ *   { selling_price: '10.00', metadata: { unique_identification_number: 'u1' } },
+ * );
+ */
+export declare function mergeOrderProductDisplayFields(previous: Record<string, any>, next: Record<string, any>): Record<string, any>;
+/**
+ * 按 uid 索引 tempOrder.products，供 applyDiscount 合并展示字段。
+ *
+ * @example
+ * indexOrderProductsByUid([{ metadata: { unique_identification_number: 'u1' } }]);
+ */
+export declare function indexOrderProductsByUid(products: Array<Record<string, any>> | null | undefined): Map<string, Record<string, any>>;
 export { createEmptySummary } from '../../solution/ScanOrder/utils';
+export { buildManualProductDiscountItem, ensureManualProductDiscountList, findManualProductDiscountItem, mergeManualProductDiscountIntoList, resolveManualDiscountMessage, resolveManualDiscountOriginTotal, resolveManualDiscountReasonFromSources, resolveSafeProductNum, shouldBuildManualProductDiscount, syncManualProductDiscountProductNum, stripManualProductDiscountItems, } from './utils/manualProductDiscount';
+export type { ManualProductDiscountItem } from './utils/manualProductDiscount';