@pisell/pisellos 0.0.567 → 0.0.569

package/lib/solution/BaseSales/index.js

@@ -0,0 +1,2367 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  BaseSalesImpl: true
+};
+exports.BaseSalesImpl = void 0;
+var _BaseModule = require("../../modules/BaseModule");
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _Order = require("../../modules/Order");
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _lodashEs = require("lodash-es");
+var _types2 = require("../BookingByStep/types");
+var _utils = require("../../modules/Order/utils");
+var _orderCollectionIdentity = require("../../modules/Order/utils/orderCollectionIdentity");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _Quotation = require("../../modules/Quotation");
+var _transformBaseProductToOrderProduct = require("./utils/transformBaseProductToOrderProduct");
+var _quotationPrice = require("./utils/quotationPrice");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SERVER_ORDER_CHANGED_EVENT = 'order:onOrdersChanged';
+function isBaseSalesManualProductDiscountProduct(product) {
+  return product?.metadata?.is_manual_discount === true || product?.metadata?.is_manual_discount === 1 || (product?.discount_list || []).some(item => item?.type === 'product');
+}
+function getBaseSalesProductUid(product) {
+  const uid = product?.metadata?.unique_identification_number || product?.unique_identification_number;
+  if (uid === undefined || uid === null || uid === '') return null;
+  return String(uid);
+}
+function preserveManualProductDiscountProducts(previousProducts, nextProducts) {
+  const previousByUid = new Map();
+  (previousProducts || []).forEach((product, index) => {
+    const uid = getBaseSalesProductUid(product);
+    if (uid) previousByUid.set(uid, product);
+    previousByUid.set(`__index__:${index}`, product);
+  });
+  return (nextProducts || []).map((product, index) => {
+    const uid = getBaseSalesProductUid(product);
+    const previous = (uid ? previousByUid.get(uid) : undefined) || previousByUid.get(`__index__:${index}`);
+    return previous && isBaseSalesManualProductDiscountProduct(previous) ? previous : product;
+  });
+}
+function isBaseSalesHistoricalDiscountEntry(discount) {
+  return Boolean(discount?.isEditMode || discount?.isDisabled || discount?.order_discount_id != null);
+}
+const BASE_SALES_PERSISTENT_ID_FIELD_BY_KIND = {
+  product: 'order_detail_id',
+  booking: 'schedule_event_id',
+  payment: 'order_payment_id'
+};
+function getBaseSalesOrderCollectionKind(key) {
+  if (key === 'products') return 'product';
+  if (key === 'bookings') return 'booking';
+  if (key === 'payments' || key === 'payment') return 'payment';
+  return null;
+}
+function isSameBaseSalesOrderRecord(left, right) {
+  if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
+  const leftIdentities = new Set([left.order_id, left.id, left.external_sale_number, left.order_number].filter(value => value !== undefined && value !== null && value !== '').map(String));
+  if (leftIdentities.size === 0) return false;
+  return [right.order_id, right.id, right.external_sale_number, right.order_number].some(value => value !== undefined && value !== null && value !== '' && leftIdentities.has(String(value)));
+}
+function isBaseSalesBlankValue(value) {
+  return value === undefined || value === null || value === '';
+}
+function mergeBaseSalesProductSnapshotFields(currentItem, loadedItem) {
+  const mergedItem = (0, _lodashEs.cloneDeep)(loadedItem);
+  if (isBaseSalesBlankValue(mergedItem.product_cover) && !isBaseSalesBlankValue(currentItem?.product_cover)) {
+    mergedItem.product_cover = currentItem.product_cover;
+  }
+  const currentHolderConfig = currentItem?.metadata?.holder_config;
+  if ((mergedItem.metadata?.holder_config === undefined || mergedItem.metadata?.holder_config === null) && currentHolderConfig !== undefined && currentHolderConfig !== null) {
+    mergedItem.metadata = {
+      ...(mergedItem.metadata || {}),
+      holder_config: currentHolderConfig
+    };
+  }
+  return mergedItem;
+}
+function mergeBaseSalesCollectionItem(kind, currentItem, incomingItem, uidRemaps) {
+  const currentReferenceUid = (0, _orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, currentItem);
+  const incomingReferenceUid = (0, _orderCollectionIdentity.getOrderCollectionReferenceUid)(kind, incomingItem);
+  const identityMergedItem = (0, _orderCollectionIdentity.mergeOrderCollectionItems)(kind, currentItem, incomingItem);
+  const mergedUid = (0, _orderCollectionIdentity.getOrderCollectionUid)(kind, identityMergedItem);
+  if (mergedUid) {
+    for (const from of new Set([currentReferenceUid, incomingReferenceUid])) {
+      if (!from || from === mergedUid) continue;
+      uidRemaps.push({
+        kind,
+        from,
+        to: mergedUid,
+        persistentId: (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, incomingItem) || (0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, currentItem)
+      });
+    }
+  }
+  const mergedItem = mergedUid ? (0, _orderCollectionIdentity.setOrderCollectionUid)(kind, incomingItem, mergedUid) : (0, _lodashEs.cloneDeep)(incomingItem);
+  const persistentIdField = BASE_SALES_PERSISTENT_ID_FIELD_BY_KIND[kind];
+  if (isBaseSalesBlankValue(mergedItem[persistentIdField]) && !isBaseSalesBlankValue(identityMergedItem[persistentIdField])) {
+    mergedItem[persistentIdField] = identityMergedItem[persistentIdField];
+  }
+  return kind === 'product' ? mergeBaseSalesProductSnapshotFields(currentItem, mergedItem) : mergedItem;
+}
+function mergeBaseSalesOrderCollection(kind, currentValue, incomingValue, strategy, uidRemaps) {
+  const currentItems = (0, _orderCollectionIdentity.normalizeOrderCollection)(kind, currentValue, {
+    ensureUid: false
+  }).items;
+  const incomingItems = (0, _orderCollectionIdentity.normalizeOrderCollection)(kind, incomingValue, {
+    ensureUid: false
+  }).items;
+  if (strategy === 'authoritative-incoming') {
+    const result = (0, _lodashEs.cloneDeep)(incomingItems);
+    currentItems.forEach(currentItem => {
+      const incomingIndex = result.findIndex(incomingItem => (0, _orderCollectionIdentity.isSameOrderCollectionItem)(kind, currentItem, incomingItem));
+      if (incomingIndex !== -1) {
+        result[incomingIndex] = mergeBaseSalesCollectionItem(kind, currentItem, result[incomingIndex], uidRemaps);
+        return;
+      }
+
+      // 完整服务端快照负责已落库行；仅保留尚未提交的本地新行。
+      if (!(0, _orderCollectionIdentity.getOrderCollectionPersistentId)(kind, currentItem)) {
+        result.push((0, _lodashEs.cloneDeep)(currentItem));
+      }
+    });
+    return result;
+  }
+  const result = (0, _lodashEs.cloneDeep)(currentItems);
+  incomingItems.forEach(incomingItem => {
+    const currentIndex = result.findIndex(currentItem => (0, _orderCollectionIdentity.isSameOrderCollectionItem)(kind, currentItem, incomingItem));
+    if (currentIndex !== -1) {
+      result[currentIndex] = mergeBaseSalesCollectionItem(kind, result[currentIndex], incomingItem, uidRemaps);
+      return;
+    }
+    result.push((0, _lodashEs.cloneDeep)(incomingItem));
+  });
+  return result;
+}
+function normalizeBaseSalesRecordCollections(sourceRecord, options) {
+  const normalizedRecord = (0, _orderCollectionIdentity.normalizeOrderCollections)((0, _lodashEs.cloneDeep)(sourceRecord || {}), options).order;
+
+  // 兼容旧调用方偶尔使用的单数 payment 字段。
+  if (Array.isArray(normalizedRecord.payment)) {
+    normalizedRecord.payment = (0, _orderCollectionIdentity.normalizeOrderCollection)('payment', normalizedRecord.payment, options).items;
+  }
+  return normalizedRecord;
+}
+function mergeSalesDetailRecordWithTempOrder(currentTempOrder, loadedRecord, strategy) {
+  const normalizedLoadedRecord = normalizeBaseSalesRecordCollections(loadedRecord || {}, {
+    ensureUid: false
+  });
+  if (!currentTempOrder) {
+    return normalizeBaseSalesRecordCollections(normalizedLoadedRecord);
+  }
+  const normalizedCurrentTempOrder = normalizeBaseSalesRecordCollections(currentTempOrder, {
+    ensureUid: false
+  });
+  const uidRemaps = [];
+  const mergedRecord = (0, _lodashEs.mergeWith)(normalizedCurrentTempOrder, normalizedLoadedRecord, (currentValue, loadedValue, key) => {
+    const collectionKind = getBaseSalesOrderCollectionKind(key);
+    if (collectionKind && Array.isArray(loadedValue)) {
+      return mergeBaseSalesOrderCollection(collectionKind, Array.isArray(currentValue) ? currentValue : [], loadedValue, strategy, uidRemaps);
+    }
+    if (Array.isArray(currentValue) && Array.isArray(loadedValue)) {
+      return [...(0, _lodashEs.cloneDeep)(currentValue), ...(0, _lodashEs.cloneDeep)(loadedValue)];
+    }
+    if (Array.isArray(loadedValue)) return (0, _lodashEs.cloneDeep)(loadedValue);
+    if (Array.isArray(currentValue) && loadedValue === undefined) {
+      return (0, _lodashEs.cloneDeep)(currentValue);
+    }
+    return undefined;
+  });
+  delete mergedRecord.request_unique_idempotency_token;
+  return normalizeBaseSalesRecordCollections((0, _orderCollectionIdentity.applyOrderCollectionUidRemaps)(mergedRecord, uidRemaps));
+}
+class BaseSalesImpl extends _BaseModule.BaseModule {
+  defaultName = 'baseSales';
+  defaultVersion = '1.0.0';
+  isSolution = true;
+  initializeOptions = {};
+  logger; // LoggerManager 实例
+  appPlugin;
+  store = {
+    order: undefined
+  };
+  otherParams = {};
+  cacheId;
+  /**
+   * window / request 暴露为 public：现存外部工具（如 BookingTicket Scan）通过
+   * `solution.window` / `solution.request` 直接访问插件，保持原有契约不破坏。
+   */
+  window;
+  request;
+
+  // 当前缓存中已加载的最新 SalesDetail；只读 getter 走它对外暴露详情数据。
+  currentSalesDetail = null;
+  discountConfigCacheKey = null;
+  hasManualDiscountSelection = false;
+  reusedSharedSubModuleNames = new Set();
+  paymentMethodsCache = [];
+  queuedAutoPaymentSync = false;
+  autoPaymentSyncFlushing = false;
+  autoPaymentSyncTimer = null;
+  salesDetailLoadInFlightCount = 0;
+  salesDetailLoadSequence = 0;
+  salesDetailHydrateQueue = Promise.resolve();
+  serverOrderChangeUnsubscribe = null;
+  serverOrderChangeHydrateInFlight = null;
+  queuedServerOrderChanges = [];
+  serverOrderChangeSyncEnabled = false;
+  constructor(name, version) {
+    super(name, version);
+  }
+
+  /**
+   * 子类可覆盖此方法以追加/收敛要注册的子模块。
+   * 默认包含通用销售模块：products / order / salesSummary / schedule / payment / quotation。
+   */
+  getRegisteredModuleNames() {
+    return ['products', 'order', 'salesSummary', 'schedule', 'payment', 'quotation'];
+  }
+  getReusableSharedSubModule(moduleName) {
+    if (moduleName !== 'schedule' && moduleName !== 'quotation') return null;
+    return this.core?.getModule?.(moduleName) || null;
+  }
+  isScheduleListLoaded(scheduleModule) {
+    if (!scheduleModule) return false;
+    if (typeof scheduleModule.isScheduleListLoaded === 'function') {
+      return scheduleModule.isScheduleListLoaded();
+    }
+    if (typeof scheduleModule.getScheduleList === 'function') {
+      return Array.isArray(scheduleModule.getScheduleList());
+    }
+    return false;
+  }
+
+  /**
+   * 记录信息日志
+   */
+  logInfo(title, metadata) {
+    if (this.logger) {
+      const tempOrder = this.getTempOrder();
+      this.logger.addLog({
+        type: 'info',
+        title: `[BaseSales]  ${tempOrder?.order_id} ${tempOrder?.external_sale_number} ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+
+  /**
+   * 记录警告日志
+   */
+  logWarning(title, metadata) {
+    if (this.logger) {
+      const tempOrder = this.getTempOrder();
+      this.logger.addLog({
+        type: 'warning',
+        title: `[BaseSales] ${tempOrder?.order_id} ${tempOrder?.external_sale_number} ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+
+  /**
+   * 记录错误日志
+   */
+  logError(title, metadata) {
+    if (this.logger) {
+      const tempOrder = this.getTempOrder();
+      this.logger.addLog({
+        type: 'error',
+        title: `[BaseSales] ${tempOrder?.order_id} ${tempOrder?.external_sale_number} ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  isCurrentSalesOrderRecord(order) {
+    const currentTempOrder = this.store.order?.getTempOrder?.();
+    const currentRecords = [currentTempOrder, this.currentSalesDetail].filter(Boolean);
+    return currentRecords.some(record => isSameBaseSalesOrderRecord(record, order));
+  }
+  setServerOrderChangeSyncEnabled(enabled) {
+    this.serverOrderChangeSyncEnabled = enabled;
+    if (!enabled) this.queuedServerOrderChanges = [];
+  }
+  queueLatestServerOrderChange(order) {
+    const snapshot = (0, _lodashEs.cloneDeep)(order);
+    const existingIndex = this.queuedServerOrderChanges.findIndex(queued => isSameBaseSalesOrderRecord(queued, snapshot));
+    if (existingIndex >= 0) {
+      this.queuedServerOrderChanges[existingIndex] = snapshot;
+      return;
+    }
+    this.queuedServerOrderChanges.push(snapshot);
+  }
+  async drainQueuedServerOrderChanges() {
+    if (!this.serverOrderChangeSyncEnabled || this.salesDetailLoadInFlightCount > 0 || this.serverOrderChangeHydrateInFlight || this.queuedServerOrderChanges.length === 0) return;
+    const changedOrders = this.queuedServerOrderChanges;
+    this.queuedServerOrderChanges = [];
+    await this.syncCurrentSalesDetailFromServerOrderChange({
+      changedOrders
+    });
+  }
+  async syncCurrentSalesDetailFromServerOrderChange(payload) {
+    const changedOrders = Array.isArray(payload) ? payload : Array.isArray(payload?.changedOrders) ? payload.changedOrders : payload?.data && typeof payload.data === 'object' ? [payload.data] : [];
+    if (!this.serverOrderChangeSyncEnabled) return;
+
+    // 显式详情加载期间 current 可能仍是上一单，先按订单身份 latest-only 缓存；
+    // load 完成后再用新的 current 过滤，避免恰好到达的最新支付快照丢失。
+    if (this.salesDetailLoadInFlightCount > 0) {
+      changedOrders.forEach(order => this.queueLatestServerOrderChange(order));
+      return;
+    }
+    const changedOrder = changedOrders.find(order => this.isCurrentSalesOrderRecord(order));
+    if (!changedOrder) return;
+    if (this.serverOrderChangeHydrateInFlight) {
+      this.queueLatestServerOrderChange(changedOrder);
+      return;
+    }
+    if (!this.store.order) return;
+    this.serverOrderChangeHydrateInFlight = (async () => {
+      const currentTempOrder = this.store.order.getTempOrder?.();
+      const record = mergeSalesDetailRecordWithTempOrder(currentTempOrder, changedOrder, 'authoritative-incoming');
+      const sales = await this.store.order.hydrateTempOrderFromRecord(record, {
+        recalcOnHydrate: false
+      });
+      this.currentSalesDetail = sales;
+      await this.core.effects.emit(`${this.name}:onSalesOrderLoaded`, {
+        sales
+      });
+    })();
+    try {
+      await this.serverOrderChangeHydrateInFlight;
+    } finally {
+      this.serverOrderChangeHydrateInFlight = null;
+      await this.drainQueuedServerOrderChanges();
+    }
+  }
+  registerServerOrderChangeSync() {
+    this.serverOrderChangeUnsubscribe?.();
+    const effects = this.core?.effects;
+    if (!effects || typeof effects.on !== 'function') return;
+    this.serverOrderChangeUnsubscribe = effects.on(SERVER_ORDER_CHANGED_EVENT, payload => {
+      return this.syncCurrentSalesDetailFromServerOrderChange(payload).catch(error => {
+        this.logError('sync sales detail from server order change failed', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    });
+  }
+  async hydrateLatestLoadedSalesDetail(record, loadSequence) {
+    let hydratedSales = null;
+    let skippedBeforeHydrate = false;
+    const hydrateTask = async () => {
+      // 网络返回顺序可能倒置；只有当前最新显式加载可以进入共享 tempOrder。
+      if (loadSequence !== this.salesDetailLoadSequence) {
+        skippedBeforeHydrate = true;
+        return;
+      }
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const sales = await this.store.order.hydrateTempOrderFromRecord(record, {
+        recalcOnHydrate: false
+      });
+      hydratedSales = sales;
+
+      // hydrate 期间可能又发起了更新请求；后续任务已串行排队，将负责最终状态。
+      if (loadSequence !== this.salesDetailLoadSequence) return;
+      this.currentSalesDetail = sales;
+      await this.core.effects.emit(`${this.name}:onSalesOrderLoaded`, {
+        sales
+      });
+    };
+    const queuedTask = this.salesDetailHydrateQueue.then(hydrateTask, hydrateTask);
+    this.salesDetailHydrateQueue = queuedTask.then(() => undefined, () => undefined);
+    await queuedTask;
+    if (skippedBeforeHydrate) return record;
+    return hydratedSales || this.currentSalesDetail || record;
+  }
+  hydrateOrderPaymentNames(payments) {
+    if (!payments.length) return [];
+    if (!this.paymentMethodsCache.length) {
+      return payments.map(payment => ({
+        ...payment
+      }));
+    }
+    const paymentMethodById = new Map();
+    const paymentMethodByCode = new Map();
+    this.paymentMethodsCache.forEach(method => {
+      if (method?.id !== undefined && method?.id !== null) {
+        paymentMethodById.set(String(method.id), method);
+      }
+      if (method?.code) {
+        paymentMethodByCode.set(String(method.code), method);
+      }
+    });
+    return payments.map(payment => {
+      const nextPayment = {
+        ...payment
+      };
+      if (nextPayment.name) return nextPayment;
+      const paymentMethod = paymentMethodById.get(String(nextPayment.custom_payment_id)) || paymentMethodByCode.get(String(nextPayment.code));
+      if (!paymentMethod?.name) return nextPayment;
+      return {
+        ...nextPayment,
+        name: paymentMethod.name
+      };
+    });
+  }
+  get payment() {
+    return this.store.payment;
+  }
+  getCurrentOrderCustomerId() {
+    const tempOrder = this.store.order?.getTempOrder?.();
+    const customerId = tempOrder?.customer_id;
+    if (customerId === null || customerId === undefined) return undefined;
+    return customerId;
+  }
+  normalizePriceContextCustomerId(customerId) {
+    if (customerId === undefined || customerId === null || customerId === '') return null;
+    return String(customerId);
+  }
+  applyQuotationScheduleResolver(quotation) {
+    const scheduleModule = this.store.schedule;
+    if (!scheduleModule) return;
+    const scheduleById = new Map();
+    const scheduleList = typeof scheduleModule.getScheduleList === 'function' ? scheduleModule.getScheduleList() : [];
+    if (Array.isArray(scheduleList)) {
+      scheduleList.forEach(schedule => {
+        if (schedule?.id !== undefined && schedule?.id !== null) {
+          scheduleById.set(String(schedule.id), schedule);
+        }
+      });
+    }
+    quotation.setScheduleResolver(id => {
+      const scheduleId = String(id);
+      if (scheduleById.has(scheduleId)) return scheduleById.get(scheduleId);
+      const schedules = scheduleModule.getScheduleListByIds?.([id]) || scheduleModule.getScheduleByIds?.([id]) || [];
+      if (schedules[0]) scheduleById.set(scheduleId, schedules[0]);
+      return schedules[0];
+    });
+  }
+  async loadQuotationForPriceQuery(params) {
+    if (!params.quotation) return;
+    this.applyQuotationScheduleResolver(params.quotation);
+    await params.quotation.loadQuotations({
+      channel: params.channel || this.otherParams?.channel,
+      customer_id: params.customer_id
+    });
+  }
+  getPriceQueryProductId(product) {
+    const productId = Number(product?.product_id ?? product?.id);
+    if (!Number.isFinite(productId)) return null;
+    return productId;
+  }
+  getPriceQuerySchedule(params) {
+    const booking = params.booking || {};
+    if (typeof booking.start_date === 'string' && booking.start_date.trim()) {
+      const scheduleDate = booking.start_date.trim();
+      const startTime = typeof booking.start_time === 'string' && booking.start_time.trim() ? booking.start_time.trim() : '00:00:00';
+      const datetime = (0, _dayjs.default)(`${scheduleDate} ${startTime}`);
+      return {
+        schedule_date: scheduleDate,
+        schedule_datetime: datetime.isValid() ? datetime.format('YYYY-MM-DD HH:mm:ss') : `${scheduleDate} ${startTime}`
+      };
+    }
+    if (typeof params.datetime === 'string' && params.datetime.trim()) {
+      const datetime = (0, _dayjs.default)(params.datetime.trim());
+      if (datetime.isValid()) {
+        return {
+          schedule_date: datetime.format('YYYY-MM-DD'),
+          schedule_datetime: datetime.format('YYYY-MM-DD HH:mm:ss')
+        };
+      }
+    }
+    const now = (0, _dayjs.default)();
+    return {
+      schedule_date: now.format('YYYY-MM-DD'),
+      schedule_datetime: now.format('YYYY-MM-DD HH:mm:ss')
+    };
+  }
+  async loadProductsForPriceQuery(params) {
+    const ids = Array.from(new Set(params.ids.filter(id => Number.isFinite(id))));
+    const productsById = new Map();
+    if (!ids.length || !this.request) return productsById;
+    try {
+      const response = await this.request.post('/product/query', {
+        ids,
+        open_quotation: 1,
+        open_bundle: 1,
+        status: 'published',
+        num: 1,
+        skip: 1,
+        customer_id: params.customerId,
+        schedule_date: params.schedule.schedule_date,
+        schedule_datetime: params.schedule.schedule_datetime,
+        application_code: params.channel || this.otherParams?.channel
+      }, {
+        osServer: true,
+        customToast: () => {}
+      });
+      const list = response?.data?.list || response?.list || [];
+      if (!Array.isArray(list)) return productsById;
+      list.forEach(item => {
+        const productId = Number(item?.id ?? item?.product_id);
+        if (Number.isFinite(productId)) productsById.set(productId, item);
+      });
+      return productsById;
+    } catch (error) {
+      this.logWarning('loadProductsForPriceQuery: 商品批量重查失败，使用入参 fallback', {
+        ids,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return productsById;
+    }
+  }
+  async loadProductForPriceQuery(params, customerId) {
+    const product = params.product || {};
+    const productId = this.getPriceQueryProductId(product);
+    if (productId === null || !this.request) return null;
+    const schedule = this.getPriceQuerySchedule(params);
+    const productsById = await this.loadProductsForPriceQuery({
+      ids: [productId],
+      schedule,
+      customerId,
+      channel: params.channel
+    });
+    return productsById.get(productId) || null;
+  }
+  getAuthoritativeBundleItems(product) {
+    if (Array.isArray(product?.product_bundle)) return product.product_bundle;
+    const groups = Array.isArray(product?.bundle_group) ? product.bundle_group : Array.isArray(product?.bundleGroup) ? product.bundleGroup : [];
+    return groups.flatMap(group => {
+      const items = Array.isArray(group?.bundle_item) ? group.bundle_item : Array.isArray(group?.bundleItem) ? group.bundleItem : [];
+      return items.map(item => ({
+        ...item,
+        group_id: item?.group_id ?? group?.id,
+        bundle_group_id: item?.bundle_group_id ?? item?.group_id ?? group?.id
+      }));
+    });
+  }
+  findAuthoritativeBundleItem(bundle, candidates) {
+    const bundleId = bundle.bundle_id ?? bundle.id;
+    if (bundleId != null) {
+      const matchedById = candidates.find(item => String(item?.bundle_id ?? item?.id) === String(bundleId));
+      if (matchedById) return matchedById;
+    }
+    const productId = bundle.bundle_product_id ?? bundle._bundle_product_id;
+    const groupId = bundle.bundle_group_id ?? bundle.group_id;
+    return candidates.find(item => {
+      const itemProductId = item?.bundle_product_id ?? item?._bundle_product_id;
+      const itemGroupId = item?.bundle_group_id ?? item?.group_id;
+      if (productId == null || String(itemProductId) !== String(productId)) return false;
+      if (groupId == null) return true;
+      return String(itemGroupId) === String(groupId);
+    }) || null;
+  }
+  getAuthoritativeBundleUnitPrice(bundle) {
+    return bundle.price ?? bundle.bundle_selling_price ?? bundle.custom_price ?? bundle.product_price ?? bundle.base_price;
+  }
+  mergeProductForPriceQuery(product, authoritativeProduct) {
+    if (!authoritativeProduct) return product;
+    const selectedBundles = Array.isArray(product.product_bundle) ? product.product_bundle : [];
+    const authoritativeBundles = this.getAuthoritativeBundleItems(authoritativeProduct);
+    const productBundle = selectedBundles.map(bundle => {
+      const authoritativeBundle = this.findAuthoritativeBundleItem(bundle, authoritativeBundles);
+      const unitPrice = authoritativeBundle ? this.getAuthoritativeBundleUnitPrice(authoritativeBundle) : undefined;
+      if (unitPrice === undefined || unitPrice === null || unitPrice === '') return bundle;
+      return {
+        ...bundle,
+        price: unitPrice,
+        bundle_selling_price: unitPrice,
+        base_price: authoritativeBundle?.base_price ?? bundle.base_price,
+        product_price: authoritativeBundle?.product_price ?? bundle.product_price
+      };
+    });
+    return {
+      ...product,
+      ...authoritativeProduct,
+      id: product.id ?? authoritativeProduct.id,
+      product_id: product.product_id ?? authoritativeProduct.product_id ?? authoritativeProduct.id,
+      product_variant_id: product.product_variant_id ?? authoritativeProduct.product_variant_id ?? 0,
+      num: product.num ?? product.quantity ?? authoritativeProduct.num,
+      quantity: product.quantity ?? product.num ?? authoritativeProduct.quantity,
+      product_sku: (() => {
+        const authoritativeSku = (0, _utils.ensureProductSku)(authoritativeProduct);
+        const productSku = (0, _utils.ensureProductSku)(product);
+        const hasProductSku = product.product_sku && typeof product.product_sku === 'object';
+        return {
+          ...authoritativeSku,
+          ...productSku,
+          option: hasProductSku ? productSku.option : authoritativeSku.option
+        };
+      })(),
+      product_bundle: productBundle,
+      metadata: product.metadata ?? authoritativeProduct.metadata
+    };
+  }
+  getSubmitOrderSalesChannel() {
+    return this.otherParams?.channel;
+  }
+
+  /**
+   * 工厂入口：根据子模块名实例化对应模块。
+   * 默认使用 BookingByStep 公共 `createModule`。子类若需引入额外类型（如 customer），
+   * 可覆盖此方法并把未识别的 name 委托给 `super.createSubModule(name)`。
+   */
+  createSubModule(moduleName) {
+    if (moduleName === 'quotation') {
+      return new _Quotation.QuotationModule(`${this.name}_quotation`);
+    }
+    return (0, _types2.createModule)(moduleName, this.name);
+  }
+  getSubModuleHooks(moduleName) {
+    const optionHooks = this.initializeOptions.hooks || {};
+    const otherHooks = this.otherParams.hooks || {};
+    if (moduleName === 'order') {
+      const directOrderHooks = optionHooks;
+      return optionHooks.order || this.otherParams.order?.hooks || otherHooks.order || (directOrderHooks.onBeforeMergeProductToOrder ? directOrderHooks : undefined);
+    }
+    return optionHooks[moduleName] || this.otherParams[moduleName]?.hooks || otherHooks[moduleName];
+  }
+
+  /**
+   * 构造传给 BaseSales 子模块的完整运行态参数，保证初始化和后续同步语义一致。
+   *
+   * @example
+   * const params = this.buildSubModuleOtherParams();
+   * this.core.registerModule(orderModule, { otherParams: params });
+   */
+  buildSubModuleOtherParams() {
+    return {
+      ...this.otherParams,
+      salesSummaryModuleName: `${this.name}_salesSummary`,
+      fatherModule: this.name,
+      openCache: this.cacheId ? true : false,
+      cacheId: this.cacheId
+    };
+  }
+
+  /**
+   * 将父级 otherParams 的变更显式同步给已注册的子模块。
+   *
+   * @example
+   * await this.syncOtherParamsToSubModules({ channel: 'pos' });
+   */
+  async syncOtherParamsToSubModules(changedParams, {
+    cover = false
+  } = {}) {
+    const nextSubModuleOtherParams = this.buildSubModuleOtherParams();
+    await Promise.all(Object.entries(this.store).map(async ([moduleName, subModule]) => {
+      if (this.reusedSharedSubModuleNames.has(moduleName)) {
+        return;
+      }
+      const targetModule = subModule;
+      if (!targetModule || typeof targetModule.updateOtherParams !== 'function') {
+        return;
+      }
+      await targetModule.updateOtherParams(nextSubModuleOtherParams, {
+        changedParams,
+        cover
+      });
+    }));
+  }
+
+  /**
+   * 读取 sessionStorage[this.name][cacheId]，作为子模块 initialState 的来源。
+   * sessionStorage 损坏时静默忽略，按空状态注册。
+   */
+  readSessionCacheData() {
+    if (!this.cacheId || !this.window) return {};
+    try {
+      const sessionData = this.window.sessionStorage.getItem(this.name);
+      if (!sessionData) return {};
+      const data = JSON.parse(sessionData);
+      return data && data[this.cacheId] || {};
+    } catch {
+      return {};
+    }
+  }
+  getAppData(key) {
+    const getData = this.appPlugin.getData?.();
+    if (typeof getData === 'function') return getData(key);
+    const app = this.appPlugin.getApp();
+    const coreData = app?.models?.getStore?.().getDataByModel?.('core', 'core');
+    return coreData?.[key];
+  }
+  syncAppDataToTempOrder(tempOrder) {
+    const isPriceIncludeTax = this.getAppData('is_price_include_tax');
+    const taxCountryCode = this.getAppData('tax_country_code');
+    const currencyCode = this.getAppData('shop_currency_code');
+    const currencySymbol = this.getAppData('shop_symbol');
+    let isChanged = false;
+    if (isPriceIncludeTax !== undefined) {
+      const nextIsPriceIncludeTax = Number(isPriceIncludeTax);
+      if ((nextIsPriceIncludeTax === 0 || nextIsPriceIncludeTax === 1) && tempOrder.is_price_include_tax !== nextIsPriceIncludeTax) {
+        tempOrder.is_price_include_tax = nextIsPriceIncludeTax;
+        isChanged = true;
+      }
+    }
+    if (taxCountryCode !== undefined) {
+      const nextTaxCountryCode = String(taxCountryCode || '');
+      if (tempOrder.tax_country_code !== nextTaxCountryCode) {
+        tempOrder.tax_country_code = nextTaxCountryCode;
+        isChanged = true;
+      }
+    }
+    if (currencyCode !== undefined) {
+      const nextCurrencyCode = String(currencyCode || '');
+      if (tempOrder.currency_code !== nextCurrencyCode) {
+        tempOrder.currency_code = nextCurrencyCode;
+        isChanged = true;
+      }
+    }
+    if (currencySymbol !== undefined) {
+      const nextCurrencySymbol = String(currencySymbol || '');
+      if (tempOrder.currency_symbol !== nextCurrencySymbol) {
+        tempOrder.currency_symbol = nextCurrencySymbol;
+        isChanged = true;
+      }
+    }
+    return isChanged;
+  }
+  async initialize(core, options = {}) {
+    this.core = core;
+    this.initializeOptions = options || {};
+    // this.store = { ...this.store, ...(options.store as Partial<BaseSalesState>) };
+    this.otherParams = options.otherParams || {};
+    this.cacheId = this.otherParams?.cacheId;
+    this.reusedSharedSubModuleNames.clear();
+    this.window = core.getPlugin('window');
+    this.request = core.getPlugin('request');
+
+    // 获取 logger 实例
+    this.appPlugin = core.getPlugin('app');
+    if (!this.appPlugin) {
+      // throw new Error('Checkout 解决方案需要 app 插件支持');
+    }
+    const app = this.appPlugin?.getApp?.();
+    this.logger = app?.logger;
+    const targetCacheData = this.readSessionCacheData();
+    const moduleNames = this.getRegisteredModuleNames();
+    moduleNames.forEach(step => {
+      const reusedModule = this.getReusableSharedSubModule(step);
+      if (reusedModule) {
+        this.store[step] = reusedModule;
+        this.reusedSharedSubModuleNames.add(step);
+        return;
+      }
+      const targetModule = this.createSubModule(step);
+      if (!targetModule) {
+        throw new Error(`模块 ${step} 不存在`);
+      }
+      const hooks = this.getSubModuleHooks(step);
+      this.store[step] = targetModule;
+      this.core.registerModule(targetModule, {
+        initialState: targetCacheData?.[targetModule.name] || {},
+        ...(hooks ? {
+          hooks
+        } : {}),
+        otherParams: this.buildSubModuleOtherParams()
+      });
+    });
+    if (this.store.schedule && !this.isScheduleListLoaded(this.store.schedule)) {
+      await this.store.schedule.loadAllSchedule();
+    }
+    if (this.store.order && typeof this.otherParams?.enableTempOrderPersist === 'boolean') {
+      this.store.order.setEnableTempOrderPersist(this.otherParams.enableTempOrderPersist);
+    }
+    await this.getPaymentMethodsAsync();
+    this.registerServerOrderChangeSync();
+    this.core.effects.emit(`${this.name}:onInited`, {});
+  }
+  async destroy() {
+    this.serverOrderChangeUnsubscribe?.();
+    this.serverOrderChangeUnsubscribe = null;
+    Object.keys(this.store).forEach(key => {
+      if (this.reusedSharedSubModuleNames.has(key)) return;
+      const sub = this.store[key];
+      if (sub && typeof sub.destroy === 'function') {
+        try {
+          sub.destroy();
+        } catch (error) {
+          console.warn(`[BaseSales] 子模块 ${key} 销毁失败`, error);
+        }
+      }
+    });
+    this.currentSalesDetail = null;
+    this.queuedServerOrderChanges = [];
+    this.salesDetailLoadSequence += 1;
+    await this.core.effects.emit(`${this.name}:onDestroy`, {});
+    super.destroy();
+  }
+
+  /**
+   * 加载销售订单到统一 tempOrder 工作区。
+   * 统一通过 OrderModule 的 sales detail lookup 加载订单详情。
+   *
+   * 子类可在 `super.loadSalesDetail` 之后基于返回的 `sales` 做业务侧装配
+   * （比如把 `sales.customer` 写入 CustomerModule、emit 业务 hook 等）。
+   */
+  async loadSalesDetail(orderIdOrParams) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const loadSequence = ++this.salesDetailLoadSequence;
+    this.salesDetailLoadInFlightCount += 1;
+    try {
+      const params = typeof orderIdOrParams === 'object' ? orderIdOrParams : {
+        orderId: orderIdOrParams
+      };
+      const externalSaleNumber = params.externalSaleNumber || params.external_sale_number;
+      const preloadedSalesDetail = params.preloadedSalesDetail;
+      const lookup = params.orderId ?? externalSaleNumber ?? params.orderNumber ?? preloadedSalesDetail?.order_id ?? preloadedSalesDetail?.external_sale_number ?? preloadedSalesDetail?.order_number;
+      if (!preloadedSalesDetail && (lookup === undefined || lookup === null || lookup === '')) {
+        throw new Error('加载销售详情需要 orderId、externalSaleNumber 或 orderNumber');
+      }
+      // GlobalSearch 等调用方已拿到完整详情时，直接进入查询成功后的 hydrate 流程，避免按 id 二次请求。
+      const loadedRecord = preloadedSalesDetail ?? (await this.store.order.getSalesOrderByLookup({
+        lookup,
+        forceRemote: params.forceRemote
+      }));
+      if (!preloadedSalesDetail && (!loadedRecord || loadedRecord.code !== 200)) {
+        const message = loadedRecord && (loadedRecord.message || loadedRecord.msg) || `加载销售详情失败: ${lookup}`;
+        throw new Error(message);
+      }
+      const remoteRecord = preloadedSalesDetail ?? loadedRecord.data;
+      const currentTempOrder = params.merge ? this.store.order.getTempOrder() : null;
+      const record = params.merge ? mergeSalesDetailRecordWithTempOrder(currentTempOrder, remoteRecord, 'preserve-local') : remoteRecord;
+      return await this.hydrateLatestLoadedSalesDetail(record, loadSequence);
+    } finally {
+      this.salesDetailLoadInFlightCount = Math.max(0, this.salesDetailLoadInFlightCount - 1);
+      if (this.salesDetailLoadInFlightCount === 0) {
+        try {
+          await this.drainQueuedServerOrderChanges();
+        } catch (error) {
+          this.logError('drain queued server order changes failed', {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  }
+
+  /** 获取当前已加载的销售详情（只读快照）。未加载过则返回 null。 */
+  getSalesOrder() {
+    return this.currentSalesDetail;
+  }
+
+  /** 获取销售详情顶部业务字段（订单号/状态/金额等通用字段集合）。 */
+  getOrderHeader() {
+    if (!this.currentSalesDetail) return null;
+    return this.currentSalesDetail.header || this.currentSalesDetail;
+  }
+
+  /** 获取所有 booking（含 root + children），按服务端原始顺序输出。 */
+  getBookings() {
+    return this.currentSalesDetail?.bookings || [];
+  }
+
+  /** 获取根 booking（is_next === 0 / is_root === 1），多个时取第一个。 */
+  getRootBooking() {
+    if (!this.currentSalesDetail) return null;
+    if (this.currentSalesDetail.rootBooking) return this.currentSalesDetail.rootBooking;
+    const bookings = this.currentSalesDetail.bookings || [];
+    return bookings.find(booking => {
+      const parentId = booking?.parent_id;
+      return parentId === 0 || parentId === null || parentId === undefined;
+    }) || null;
+  }
+
+  /** 按 product_uid 反查 booking 列表（用于商品行 ↔ booking 映射）。 */
+  getChildBookingsByProductUid(productUid) {
+    if (!this.currentSalesDetail || !productUid) return [];
+    const indexed = this.currentSalesDetail.bookingsByProductUid?.[productUid];
+    if (indexed) return indexed;
+    return (this.currentSalesDetail.bookings || []).filter(booking => {
+      const uid = booking?.product_uid || booking?.metadata?.product_uid;
+      return String(uid || '') === String(productUid);
+    });
+  }
+
+  /** 获取支付列表（已支付/退款等明细）。 */
+  getPayments() {
+    return this.currentSalesDetail?.payments || [];
+  }
+
+  /** 获取附加费用（运费/服务费/税费等）。 */
+  getSurcharges() {
+    return this.currentSalesDetail?.surcharges || [];
+  }
+  getTempOrder() {
+    const result = this.store.order?.getTempOrder() || null;
+    return result;
+  }
+  async replaceTempOrder(tempOrder) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const nextTempOrder = await this.store.order.replaceTempOrder(tempOrder);
+    await this.effectsEmit('onTempOrderReplaced', {
+      tempOrder: nextTempOrder
+    });
+    return nextTempOrder;
+  }
+  getOrderIdentity() {
+    if (!this.store.order) return null;
+    return this.store.order.getOrderIdentity();
+  }
+  getOrderSnapshot() {
+    if (!this.store.order) return null;
+    return this.store.order.getOrderSnapshot();
+  }
+  getOrderSyncState() {
+    if (!this.store.order) return 'local';
+    return this.store.order.getOrderSyncState();
+  }
+  getOrderAmountSnapshot() {
+    if (!this.store.order) return null;
+    return this.store.order.getOrderAmountSnapshot();
+  }
+  getTempOrderNote() {
+    if (!this.store.order) return '';
+    return this.store.order.getTempOrderNote();
+  }
+  updateTempOrderNote(note, sync = false) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const result = this.store.order.updateTempOrderNote(note, sync);
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  updateRemoteOrderNote(orderId, note) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    this.store.order.syncTempOrderNoteToRemote(orderId, note);
+  }
+  updateTempOrderShopDiscount(amount) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.updateTempOrderShopDiscount(amount);
+  }
+  updateTempOrderDepositAmount(amount) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.updateTempOrderDepositAmount(amount);
+  }
+  updateTempOrderContactsInfo(contactsInfo) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.updateTempOrderContactsInfo(contactsInfo);
+  }
+
+  /** @deprecated OrderModule 不再负责 tempOrder localStorage 持久化。 */
+  setEnableTempOrderPersist(enabled) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    this.store.order.setEnableTempOrderPersist(enabled);
+  }
+
+  /** 是否允许 saveDraft 写入 IndexedDB 草稿。 */
+  isTempOrderPersistEnabled() {
+    if (!this.store.order) return false;
+    return this.store.order.isTempOrderPersistEnabled();
+  }
+  ensureTempOrder() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.ensureTempOrder();
+  }
+
+  // 主动创建临时订单；若已存在则直接返回已有订单
+  async addNewOrder() {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const tempOrder = await this.store.order.addNewOrder();
+      if (this.syncAppDataToTempOrder(tempOrder) && this.isTempOrderPersistEnabled()) {
+        this.store.order.persistTempOrder();
+        await this.store.order.saveDraft();
+      }
+      return tempOrder;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async saveDraft() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.saveDraft();
+  }
+
+  // 重置 tempOrder 与与上一单强相关的运行态（resource/entryPaxNumber/enabledReservationRuleProducts），
+  // 适用于从支付页通过 react-router 跳回继续下单时清理残留数据
+  async restoreOrder() {
+    try {
+      if (!this.store.order) {
+        throw new Error('scanOrder 解决方案需要 order 模块支持');
+      }
+      // this.store.resource = null;
+      const tempOrder = this.store.order.restoreOrder();
+      this.currentSalesDetail = null;
+      this.discountConfigCacheKey = null;
+      this.hasManualDiscountSelection = false;
+      await this.effectsEmit('onTempOrderReplaced', {
+        tempOrder
+      });
+      if (this.syncAppDataToTempOrder(tempOrder) && this.isTempOrderPersistEnabled()) {
+        this.store.order.persistTempOrder();
+        await this.store.order.saveDraft();
+      }
+      return tempOrder;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * 仅清空 tempOrder 购物车行（products / bookings / discount_list）。
+   * 同步清空内存中的 salesDetail 商品/预约视图，避免编辑态仍读到旧 bookings。
+   */
+  async clearOrderCartLines() {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const tempOrder = await this.store.order.clearOrderCartLines();
+      if (this.currentSalesDetail) {
+        this.currentSalesDetail = {
+          ...this.currentSalesDetail,
+          products: [],
+          bookings: [],
+          rootBooking: null,
+          bookingsByProductUid: {},
+          discount_list: []
+        };
+      }
+      await this.effectsEmit('onTempOrderReplaced', {
+        tempOrder
+      });
+      if (this.syncAppDataToTempOrder(tempOrder) && this.isTempOrderPersistEnabled()) {
+        this.store.order.persistTempOrder();
+        await this.store.order.saveDraft();
+      }
+      return tempOrder;
+    } catch (error) {
+      throw error;
+    }
+  }
+  getOrderProducts() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const products = this.store.order.getOrderProducts();
+    return products;
+  }
+  async getSummary() {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const summary = await this.store.order.getOrderSummary();
+      return summary;
+    } catch (error) {
+      throw error;
+    }
+  }
+  getHistoricalProductDiscountList(products) {
+    const historyDiscountList = [];
+    products.forEach(item => {
+      if (!this.isPersistedOrderProduct(item)) return;
+      (item.discount_list || []).forEach(discount => {
+        const discountId = discount.discount?.resource_id || discount.id;
+        if (!discountId || !['good_pass', 'discount_card'].includes(discount.type)) return;
+        const quantity = item.quantity || item.num || item.product_quantity || 1;
+        const savedAmount = new _decimal.default(discount.amount || 0).times(quantity).plus(discount?.metadata?.product_discount_difference || 0);
+        const index = historyDiscountList.findIndex(n => n.id === discountId);
+        if (index !== -1) {
+          historyDiscountList[index] = {
+            ...historyDiscountList[index],
+            amount: new _decimal.default(historyDiscountList[index].amount || 0).plus(discount.amount || 0).toNumber(),
+            savedAmount: savedAmount.plus(historyDiscountList[index].savedAmount || 0).toNumber()
+          };
+          return;
+        }
+        historyDiscountList.push({
+          ...discount,
+          id: discountId,
+          tag: discount.tag || discount.type,
+          name: discount.name || discount.discount?.title?.auto,
+          format_title: discount.discount?.title || discount.format_title,
+          isEditMode: true,
+          limited_relation_product_data: {},
+          savedAmount: savedAmount.toNumber(),
+          isAvailable: true,
+          isDisabled: true,
+          isSelected: true,
+          product_id: discount.discount?.product_id || discount.product_id
+        });
+      });
+    });
+    return historyDiscountList;
+  }
+  isPersistedOrderProduct(product) {
+    const orderDetailId = product.order_detail_id ?? product.orderDetailId;
+    if (orderDetailId !== undefined && orderDetailId !== null && orderDetailId !== '') {
+      return true;
+    }
+    const bookingId = product.booking_id ?? product.bookingId;
+    return bookingId !== undefined && bookingId !== null && bookingId !== '';
+  }
+  mergeHistoricalDiscountList(discountList, products) {
+    const historyDiscountList = this.getHistoricalProductDiscountList(products);
+    const historyIds = new Set(historyDiscountList.map(discount => discount.id));
+    return [...historyDiscountList, ...(discountList || []).filter(discount => {
+      if (!historyIds.has(discount.id)) return true;
+      return !isBaseSalesHistoricalDiscountEntry(discount);
+    })];
+  }
+  shouldSkipAutoApplyFetchedDiscountsInEditMode(params) {
+    if (params.discountAction !== 'edit') return false;
+    if (!params.products.length) return false;
+    const hasDraftProduct = params.products.some(product => !this.isPersistedOrderProduct(product));
+    if (hasDraftProduct) return false;
+    const hasSelectedDiscount = params.currentDiscountList.some(discount => discount.isSelected || discount.isEditMode || discount.isManualSelect);
+    if (hasSelectedDiscount) return false;
+    return !params.nextDiscountList.some(discount => discount.isSelected || discount.isEditMode || discount.isManualSelect);
+  }
+  mergeCurrentDiscountSelectionState(discountList, currentDiscountList) {
+    if (!currentDiscountList.length) return discountList;
+    const currentDiscountMap = new Map();
+    currentDiscountList.forEach(discount => {
+      currentDiscountMap.set(`${discount.id}:${isBaseSalesHistoricalDiscountEntry(discount) ? 'historical' : 'runtime'}`, discount);
+    });
+    return discountList.map(discount => {
+      const currentDiscount = currentDiscountMap.get(`${discount.id}:${isBaseSalesHistoricalDiscountEntry(discount) ? 'historical' : 'runtime'}`);
+      if (!currentDiscount) return discount;
+      if (currentDiscount.isManualSelect) {
+        return {
+          ...discount,
+          isSelected: false,
+          isManualSelect: true
+        };
+      }
+      if (currentDiscount.isSelected) {
+        return {
+          ...discount,
+          isSelected: true,
+          isManualSelect: false
+        };
+      }
+      return discount;
+    });
+  }
+  async loadDiscountConfig(params) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const tempOrder = this.store.order.ensureTempOrder();
+    const orderStore = this.store.order.store || {};
+    const discountModule = orderStore.discount;
+    const rulesModule = orderStore.rules;
+    const orderId = tempOrder.order_id || this.getOrderIdentity?.()?.orderId;
+    const customerId = Number(params?.customerId || tempOrder.customer_id || tempOrder.customer?.id || tempOrder._extend?.customerSnapshot?.id || tempOrder._extend?.customerSnapshot?.customer_id || 0);
+    const currentDiscountList = discountModule?.getDiscountList?.() || [];
+    const originalDiscountList = discountModule?.getOriginalDiscountList?.() || [];
+    const hasManualDiscountSelection = this.hasManualDiscountSelection || currentDiscountList.some(discount => discount.isManualSelect);
+    const discountAction = params?.action || (orderId ? 'edit' : 'create');
+    const discountConfigCacheKey = [customerId, discountAction, Number(orderId) || 0].join(':');
+    let preparedDiscountList = [];
+    if (customerId && customerId !== 1) {
+      if (this.discountConfigCacheKey === discountConfigCacheKey) {
+        preparedDiscountList = originalDiscountList;
+      } else {
+        preparedDiscountList = await this.store.order.loadDiscountConfig({
+          customerId,
+          action: discountAction,
+          orderId: Number(orderId) || undefined,
+          apply: false
+        });
+        this.discountConfigCacheKey = discountConfigCacheKey;
+        await discountModule?.setOriginalDiscountList?.(preparedDiscountList);
+      }
+    }
+    if (hasManualDiscountSelection && currentDiscountList.length) {
+      return {
+        productList: tempOrder.products || [],
+        discountList: currentDiscountList,
+        availableWalletIds: this.getAvailableWalletIds()
+      };
+    }
+    let nextDiscountList = this.mergeHistoricalDiscountList(preparedDiscountList || discountModule?.getDiscountList?.() || [], tempOrder.products || []);
+    nextDiscountList = this.mergeCurrentDiscountSelectionState(nextDiscountList, currentDiscountList);
+    await discountModule?.setDiscountList(nextDiscountList);
+    const shouldSkipAutoApplyFetchedDiscounts = this.shouldSkipAutoApplyFetchedDiscountsInEditMode({
+      discountAction,
+      products: tempOrder.products || [],
+      currentDiscountList,
+      nextDiscountList
+    });
+    if (shouldSkipAutoApplyFetchedDiscounts) {
+      const summary = await this.store.order.recalculateSummary({
+        createIfMissing: true
+      });
+      this.store.order.persistTempOrder();
+      await this.effectsEmit('onDiscountApplied', {
+        productList: tempOrder.products || [],
+        discountList: nextDiscountList,
+        selectedDiscountList: tempOrder.discount_list || [],
+        tempOrder
+      });
+      return {
+        productList: tempOrder.products || [],
+        discountList: nextDiscountList,
+        availableWalletIds: this.getAvailableWalletIds()
+      };
+    }
+    if (rulesModule) {
+      const orderTotalAmount = Number(orderStore.summary?.total_amount || 0);
+      const result = rulesModule.calcDiscount({
+        productList: tempOrder.products,
+        discountList: nextDiscountList,
+        holders: [],
+        isFormSubject: product => (0, _utils.resolveIsFormSubject)(tempOrder, product),
+        orderTotalAmount
+      }) || {
+        productList: tempOrder.products,
+        discountList: nextDiscountList
+      };
+      if (result.productList) {
+        tempOrder.products = preserveManualProductDiscountProducts(tempOrder.products, result.productList);
+      }
+      for (const product of tempOrder.products || []) {
+        const productUid = product.metadata?.unique_identification_number;
+        const runtimeOrigin = productUid ? tempOrder._extend?.productsByUid?.[productUid]?.origin : undefined;
+        if (runtimeOrigin?.isManualDiscount || isBaseSalesManualProductDiscountProduct(product)) continue;
+        const totalPerUnitDiscount = (product.discount_list || []).reduce((sum, pd) => sum + Number(pd.amount || 0), 0);
+        const optionSum = (0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(product));
+        const sourcePrice = product.metadata?.source_product_price ?? (product.metadata?.main_product_original_price != null ? new _decimal.default(Number(product.metadata.main_product_original_price) || 0).minus(optionSum).toFixed(2) : product.original_price ?? '0');
+        const newSourceSellingPrice = new _decimal.default(Number(sourcePrice) || 0).minus(totalPerUnitDiscount).toDecimalPlaces(2).toString();
+        const newMainSellingPrice = new _decimal.default(Number(newSourceSellingPrice) || 0).plus(optionSum).toDecimalPlaces(2).toFixed(2);
+        if (product.metadata) {
+          product.metadata.main_product_selling_price = newMainSellingPrice;
+          product.metadata.price_schema_version = 2;
+        }
+        product.selling_price = (0, _utils.composeLinePrice)({
+          mainPrice: newMainSellingPrice,
+          bundle: product.product_bundle
+        });
+      }
+      if (result.discountList) {
+        nextDiscountList = this.mergeHistoricalDiscountList(result.discountList, tempOrder.products || []);
+        _Order.OrderModule.populateSavedAmounts(tempOrder.products, nextDiscountList);
+        await discountModule?.setDiscountList(nextDiscountList);
+        tempOrder.discount_list = nextDiscountList.filter(discount => discount.isSelected);
+      }
+    }
+    const summary = await this.store.order.recalculateSummary({
+      createIfMissing: true
+    });
+    this.store.order.persistTempOrder();
+    await this.effectsEmit('onDiscountApplied', {
+      productList: tempOrder.products || [],
+      discountList: nextDiscountList,
+      selectedDiscountList: tempOrder.discount_list || [],
+      tempOrder
+    });
+    return {
+      productList: tempOrder.products || [],
+      discountList: nextDiscountList,
+      availableWalletIds: this.getAvailableWalletIds()
+    };
+  }
+  getAvailableWalletIds() {
+    if (!this.store.order?.getAvailableWalletIds) return [];
+    return this.store.order.getAvailableWalletIds();
+  }
+  async bestDiscount(cb) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const tempOrder = this.store.order.ensureTempOrder();
+    const orderStore = this.store.order.store || {};
+    const discountModule = orderStore.discount;
+    const rulesModule = orderStore.rules;
+    const originalDiscountList = discountModule?.getOriginalDiscountList?.() || this.getDiscountList();
+    const currentDiscountList = discountModule?.getDiscountList?.() || [];
+    let nextDiscountList = this.mergeHistoricalDiscountList(originalDiscountList || [], tempOrder.products || []);
+    let result = {
+      productList: tempOrder.products || [],
+      discountList: nextDiscountList
+    };
+    await discountModule?.setDiscountList(nextDiscountList);
+    if (rulesModule) {
+      const orderTotalAmount = Number(orderStore.summary?.total_amount || 0);
+      result = rulesModule.calcDiscount({
+        productList: tempOrder.products,
+        discountList: nextDiscountList,
+        holders: [],
+        isFormSubject: product => (0, _utils.resolveIsFormSubject)(tempOrder, product),
+        orderTotalAmount
+      }) || result;
+      if (result.productList) {
+        tempOrder.products = preserveManualProductDiscountProducts(tempOrder.products, result.productList);
+      }
+      if (result.discountList) {
+        nextDiscountList = this.mergeHistoricalDiscountList(result.discountList, tempOrder.products || []);
+        _Order.OrderModule.populateSavedAmounts(tempOrder.products, nextDiscountList);
+        await discountModule?.setDiscountList(nextDiscountList);
+        tempOrder.discount_list = nextDiscountList.filter(discount => discount.isSelected);
+        result = {
+          productList: tempOrder.products,
+          discountList: nextDiscountList
+        };
+      }
+    }
+    await this.store.order.recalculateSummary({
+      createIfMissing: true
+    });
+    this.store.order.persistTempOrder();
+    await this.effectsEmit('onDiscountApplied', {
+      productList: tempOrder.products || [],
+      discountList: nextDiscountList,
+      selectedDiscountList: tempOrder.discount_list || [],
+      tempOrder
+    });
+    cb?.(result);
+    return result;
+  }
+  getDiscountList() {
+    if (!this.store.order) return [];
+    return this.store.order.getDiscountList();
+  }
+
+  /** 读取 Discount 模块原始券列表（未经过 bookingTime 等过滤）。 */
+  getOriginalDiscountList() {
+    if (!this.store.order) return [];
+    const discountModule = this.store.order.store?.discount;
+    return discountModule?.getOriginalDiscountList?.() || [];
+  }
+
+  /**
+   * 同步写入 Discount 模块的 discountList / originalDiscountList。
+   * 供 Holder 补全等场景在 OS store 层更新 machinecode holder 字段。
+   */
+  async replaceDiscountStoreLists(params) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const discountModule = this.store.order.store?.discount;
+    if (!discountModule) return;
+    if (params.originalDiscountList) {
+      await discountModule.setOriginalDiscountList(params.originalDiscountList);
+    }
+    await discountModule.setDiscountList(params.discountList);
+  }
+  async scanPromotionCode(code, customerId) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const raw = await this.store.order.scanCode(code, customerId);
+      if (raw.isAvailable) {
+        await this.store.order.recalculateSummary({
+          createIfMissing: true
+        });
+        this.store.order.persistTempOrder();
+        const tempOrder = this.store.order.ensureTempOrder();
+        await this.effectsEmit('onDiscountApplied', {
+          productList: tempOrder.products || [],
+          discountList: this.store.order.getDiscountList(),
+          selectedDiscountList: tempOrder.discount_list || [],
+          tempOrder
+        });
+      }
+      return {
+        isAvailable: raw.isAvailable,
+        type: raw.type,
+        unavailableReason: raw.unavailableReason,
+        scannedDiscountList: raw.scannedDiscountList
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  // TODO 需要优化，这段逻辑太长了，里面应该有些历史遗留问题
+  async setDiscountSelected(params) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const list = this.store.order.getDiscountList();
+      const updated = list.map(d => d.id === params.discountId && !isBaseSalesHistoricalDiscountEntry(d) ? {
+        ...d,
+        isSelected: params.isSelected,
+        isManualSelect: !params.isSelected
+      } : d);
+      this.hasManualDiscountSelection = true;
+      const tempOrder = this.store.order.ensureTempOrder();
+      const orderStore = this.store.order.store || {};
+      const discountModule = orderStore.discount;
+      const rulesModule = orderStore.rules;
+      let nextDiscountList = updated;
+      await discountModule?.setDiscountList(updated);
+      if (rulesModule) {
+        const orderTotalAmount = Number(orderStore.summary?.total_amount || 0);
+        const result = rulesModule.calcDiscount({
+          productList: tempOrder.products,
+          discountList: updated,
+          holders: [],
+          isFormSubject: product => (0, _utils.resolveIsFormSubject)(tempOrder, product),
+          orderTotalAmount
+        }, {
+          discountId: params.discountId,
+          isSelected: params.isSelected
+        }) || {
+          productList: tempOrder.products,
+          discountList: updated
+        };
+        if (result?.productList) {
+          tempOrder.products = preserveManualProductDiscountProducts(tempOrder.products, result.productList);
+        }
+        if (result?.discountList) {
+          nextDiscountList = result.discountList;
+          if (!params.isSelected) {
+            const beforeSelectedIds = new Set(updated.filter(d => d.isSelected).map(d => d.id));
+            for (const d of nextDiscountList) {
+              if (d.isSelected && !beforeSelectedIds.has(d.id)) {
+                d.isSelected = false;
+                d.isManualSelect = true;
+                d.appliedProductDetails = [];
+              }
+            }
+          }
+        }
+      }
+      const selectedResourceIds = new Set(nextDiscountList.filter(d => d.isSelected).map(d => d.id));
+      const filterSelectedDiscountDetails = discountList => (discountList || []).filter(pd => {
+        const rid = pd.discount?.resource_id ?? pd.id;
+        return rid != null && selectedResourceIds.has(rid);
+      });
+      for (const product of tempOrder.products) {
+        const productUid = product.metadata?.unique_identification_number;
+        const runtimeOrigin = productUid ? tempOrder._extend?.productsByUid?.[productUid]?.origin : undefined;
+        if (runtimeOrigin?.isManualDiscount || isBaseSalesManualProductDiscountProduct(product)) continue;
+        product.discount_list = filterSelectedDiscountDetails(product.discount_list);
+        if (Array.isArray(product.product_bundle)) {
+          product.product_bundle = product.product_bundle.map(bundle => {
+            const nextBundleDiscountList = filterSelectedDiscountDetails(bundle?.discount_list);
+            const shouldRestoreBundlePrice = nextBundleDiscountList.length === 0;
+            const restoredBundlePrice = bundle?.original_price ?? bundle?.product_price ?? bundle?.price;
+            return {
+              ...bundle,
+              ...(shouldRestoreBundlePrice ? {
+                price: restoredBundlePrice,
+                bundle_selling_price: restoredBundlePrice
+              } : {}),
+              discount_list: nextBundleDiscountList
+            };
+          });
+        }
+
+        // 券作用于 source（不含 option、不含 bundle）；算出新 source 折后价后补回 options
+        // 写入含 option 的 main_product_selling_price，再合成 composite 回写 selling_price。
+        const totalPerUnitDiscount = (product.discount_list || []).reduce((sum, pd) => sum + (pd.amount || 0), 0);
+        // TODO 这块逻辑需要拿掉
+        const optionSum = (0, _utils.sumOptionUnitPrice)((0, _utils.getProductSkuOptions)(product));
+        const sourcePrice = product.metadata?.source_product_price ?? (product.metadata?.main_product_original_price != null ? new _decimal.default(Number(product.metadata.main_product_original_price) || 0).minus(optionSum).toFixed(2) : product.original_price ?? '0');
+        const newSourceSellingPrice = new _decimal.default(Number(sourcePrice) || 0).minus(totalPerUnitDiscount).toDecimalPlaces(2).toString();
+        const newMainSellingPrice = new _decimal.default(Number(newSourceSellingPrice) || 0).plus(optionSum).toDecimalPlaces(2).toFixed(2);
+        if (product.metadata) {
+          product.metadata.main_product_selling_price = newMainSellingPrice;
+          product.metadata.price_schema_version = 2;
+        }
+        product.selling_price = (0, _utils.composeLinePrice)({
+          mainPrice: newMainSellingPrice,
+          bundle: product.product_bundle
+        });
+      }
+      _Order.OrderModule.populateSavedAmounts(tempOrder.products, nextDiscountList);
+      await discountModule?.setDiscountList(nextDiscountList);
+      tempOrder.discount_list = (nextDiscountList || []).filter(d => d.isSelected);
+      await this.store.order.recalculateSummary({
+        createIfMissing: true
+      });
+      this.store.order.persistTempOrder();
+      this.effectsEmit('onDiscountApplied', {
+        productList: tempOrder.products,
+        discountList: nextDiscountList,
+        selectedDiscountList: tempOrder.discount_list,
+        tempOrder
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async applyDiscountCalculationResult(result) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      if (!result) return;
+      const tempOrder = this.store.order.ensureTempOrder();
+      const orderStore = this.store.order.store || {};
+      const discountModule = orderStore.discount;
+      if (result.productList) {
+        tempOrder.products = preserveManualProductDiscountProducts(tempOrder.products, result.productList);
+      }
+      if (result.discountList) {
+        _Order.OrderModule.populateSavedAmounts(tempOrder.products, result.discountList);
+        await discountModule?.setDiscountList(result.discountList);
+        tempOrder.discount_list = result.discountList.filter(discount => discount.isSelected);
+      }
+      await this.store.order.recalculateSummary({
+        createIfMissing: true
+      });
+      this.store.order.persistTempOrder();
+      await this.effectsEmit('onDiscountApplied', {
+        productList: tempOrder.products || [],
+        discountList: result.discountList || [],
+        selectedDiscountList: tempOrder.discount_list || [],
+        tempOrder
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async submitScanOrder(params) {
+    // Deprecated compatibility alias. New BaseSales callers should use submitSalesOrder.
+    return this.submitSalesOrder(params);
+  }
+
+  /**
+   * 提交当前 Sales 订单。
+   *
+   * PaymentModal 场景通过 smallTicketDataFlag=1 请求 B 端小票数据；
+   * payments 会交给 OrderModule 统一映射为 Sales 协议支付项。
+   */
+  async submitSalesOrder(params) {
+    if (!this.store.order) {
+      throw new Error('BaseSales 解决方案需要 order 模块支持');
+    }
+    // this.store.order.persistTempOrder();
+    const inferredPaymentStatus = this.getSubmitPaymentStatus(params?.paymentStatus);
+    const smallTicketDataFlag = params?.smallTicketDataFlag ?? this.getDefaultCheckoutSmallTicketDataFlag();
+    const submitParams = {
+      cacheId: this.cacheId,
+      platform: this.otherParams?.platform,
+      businessCode: this.otherParams?.businessCode || this.otherParams?.business_code,
+      channel: this.getSubmitOrderSalesChannel(),
+      type: this.otherParams?.type,
+      request_unique_idempotency_token: this.store.order.generateIdempotencyToken(),
+      ...(params?.payments !== undefined ? {
+        payments: params.payments
+      } : {}),
+      ...(inferredPaymentStatus !== undefined ? {
+        paymentStatus: inferredPaymentStatus
+      } : {}),
+      ...(smallTicketDataFlag !== undefined ? {
+        smallTicketDataFlag
+      } : {}),
+      ...(params?.confirmPendingVoucherPayments !== undefined ? {
+        confirmPendingVoucherPayments: params.confirmPendingVoucherPayments
+      } : {}),
+      ...(params?.enhancePayload !== undefined ? {
+        enhancePayload: params.enhancePayload
+      } : {})
+    };
+    return this.shouldUseCheckoutSyncTask() ? this.store.order.submitTempOrder(submitParams) : this.store.order.submitTempOrderAsync(submitParams);
+  }
+  async submitTempOrderAsync(params) {
+    if (!this.store.order) {
+      throw new Error('BaseSales 解决方案需要 order 模块支持');
+    }
+    const inferredPaymentStatus = this.getSubmitPaymentStatus(params?.paymentStatus);
+    const smallTicketDataFlag = params?.smallTicketDataFlag ?? this.getDefaultCheckoutSmallTicketDataFlag();
+    const submitParams = {
+      cacheId: this.cacheId,
+      platform: this.otherParams?.platform,
+      businessCode: this.otherParams?.businessCode || this.otherParams?.business_code,
+      channel: this.getSubmitOrderSalesChannel(),
+      type: this.otherParams?.type,
+      request_unique_idempotency_token: this.store.order.generateIdempotencyToken(),
+      ...(params?.payments !== undefined ? {
+        payments: params.payments
+      } : {}),
+      ...(inferredPaymentStatus !== undefined ? {
+        paymentStatus: inferredPaymentStatus
+      } : {}),
+      ...(smallTicketDataFlag !== undefined ? {
+        smallTicketDataFlag
+      } : {}),
+      ...(params?.confirmPendingVoucherPayments !== undefined ? {
+        confirmPendingVoucherPayments: params.confirmPendingVoucherPayments
+      } : {}),
+      ...(params?.enhancePayload !== undefined ? {
+        enhancePayload: params.enhancePayload
+      } : {})
+    };
+    return this.store.order.submitTempOrderAsync(submitParams);
+  }
+
+  /**
+   * 默认保持 WebPOS 的本地待同步订单模式；需要云端确认后才算成功的渠道可覆盖此策略。
+   * otherParams.checkoutSyncTaskEnabled 优先，便于同一 solution 按入口恢复旧行为。
+   */
+  shouldUseCheckoutSyncTask() {
+    const configured = this.otherParams?.checkoutSyncTaskEnabled;
+    return typeof configured === 'boolean' ? configured : true;
+  }
+
+  /** 可由特定 solution 为真实 checkout 补充默认收据数据请求。 */
+  getDefaultCheckoutSmallTicketDataFlag() {
+    return undefined;
+  }
+  async printLocalOrderReceipt(lookup) {
+    if (!this.store.order) {
+      throw new Error('BaseSales 解决方案需要 order 模块支持');
+    }
+    const hasLookup = lookup !== undefined && lookup !== null && lookup !== '';
+    const lookupPayload = typeof lookup === 'number' ? {
+      order_id: lookup
+    } : {
+      external_sale_number: lookup
+    };
+    const context = {
+      platform: this.otherParams?.platform,
+      businessCode: this.otherParams?.businessCode || this.otherParams?.business_code,
+      channel: this.getSubmitOrderSalesChannel(),
+      type: this.otherParams?.type
+    };
+    const payload = hasLookup ? {
+      ...lookupPayload,
+      lookup_order_from_db: 1,
+      small_ticket_data_flag: 1,
+      platform: context.platform,
+      business_code: context.businessCode,
+      order_sales_channel: context.channel,
+      type: context.type
+    } : this.store.order.buildCurrentSubmitPayloadForLocalPrint({
+      cacheId: this.cacheId,
+      platform: context.platform,
+      businessCode: context.businessCode,
+      channel: context.channel,
+      type: context.type
+    });
+    const response = await this.request.post('/local/print-order', payload, {
+      osServer: true,
+      customToast: () => {}
+    });
+    if (!hasLookup) {
+      await this.store.order.applyLocalPrintOrderNumbers?.(response?.data?.order);
+    }
+    return response;
+  }
+  getSubmitPaymentStatus(paymentStatus) {
+    if (paymentStatus !== undefined) return paymentStatus;
+    const amountSnapshot = this.store.order?.getOrderAmountSnapshot?.();
+    if (!amountSnapshot) return undefined;
+    try {
+      return new _decimal.default(amountSnapshot.amountGap || 0).lte(0) ? 'paid' : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  async syncPaymentsToOrder(params) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const businessCode = params.businessCode ?? this.otherParams?.businessCode ?? this.otherParams?.business_code;
+    const channel = params.channel ?? this.getSubmitOrderSalesChannel();
+    const syncParams = {
+      ...params,
+      checkoutSyncTaskEnabled: this.shouldUseCheckoutSyncTask(),
+      ...(businessCode !== undefined ? {
+        businessCode
+      } : {}),
+      ...(channel !== undefined ? {
+        channel
+      } : {})
+    };
+    const syncState = this.store.order.getOrderSyncState();
+    if (params.submitWhenPaid && syncState === 'submitting') {
+      this.queueLatestAutoPaymentSync();
+      return this.store.order.syncPaymentsToOrder(syncParams);
+    }
+    const payments = params.payments || [];
+    await this.effectsEmit(_types.BaseSalesHookNames.onPaymentSyncStart, {
+      payments,
+      params: syncParams,
+      amountSnapshot: this.store.order.getOrderAmountSnapshot(),
+      orderSnapshot: this.store.order.getOrderSnapshot()
+    });
+    try {
+      const syncResult = await this.store.order.syncPaymentsToOrder(syncParams);
+      const latestPayments = this.store.order.getOrderPayments();
+      const amountSnapshot = this.store.order.getOrderAmountSnapshot();
+      const orderSnapshot = this.store.order.getOrderSnapshot();
+      const syncPayload = {
+        ok: true,
+        syncResult,
+        payments: latestPayments,
+        params: syncParams,
+        amountSnapshot,
+        orderSnapshot,
+        isFullyPaid: syncResult.isFullyPaid,
+        isOrderFullyPaid: syncResult.isOrderFullyPaid,
+        isDepositFullyPaid: syncResult.isDepositFullyPaid,
+        paymentStage: syncResult.paymentStage,
+        depositAmount: syncResult.depositAmount,
+        orderExpectedAmount: syncResult.orderExpectedAmount
+      };
+      await this.effectsEmit(_types.BaseSalesHookNames.onPaymentSyncEnd, syncPayload);
+      if (syncResult.isDepositFullyPaid && !syncResult.isOrderFullyPaid) {
+        await this.effectsEmit(_types.BaseSalesHookNames.onDepositPaymentSyncEnd, syncPayload);
+      }
+      this.scheduleQueuedAutoPaymentSyncFlush(0);
+      return syncResult;
+    } catch (error) {
+      await this.effectsEmit(_types.BaseSalesHookNames.onPaymentSyncEnd, {
+        ok: false,
+        error,
+        payments: this.store.order.getOrderPayments(),
+        params: syncParams,
+        amountSnapshot: this.store.order.getOrderAmountSnapshot(),
+        orderSnapshot: this.store.order.getOrderSnapshot()
+      });
+      this.scheduleQueuedAutoPaymentSyncFlush(0);
+      throw error;
+    }
+  }
+
+  /** 读取当前 BaseSales 订单上下文中的 Sales 协议支付项。 */
+  getOrderPayments() {
+    if (!this.store.order) return [];
+    const payments = this.store.order.getOrderPayments();
+    return this.hydrateOrderPaymentNames(payments);
+  }
+
+  /** 覆盖当前订单支付项，内部由 OrderModule 清洗为 Sales 协议字段。 */
+  setOrderPayments(payments) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.setOrderPayments(payments);
+  }
+  getPaymentStatusForSync(payments) {
+    const order = this.store.order;
+    if (!order) throw new Error('order 模块未初始化');
+    const completion = order.getPaymentCompletion(payments);
+    return completion.isOrderFullyPaid ? 'paid' : 'partially_paid';
+  }
+  queueLatestAutoPaymentSync() {
+    this.queuedAutoPaymentSync = true;
+    this.scheduleQueuedAutoPaymentSyncFlush();
+  }
+  scheduleQueuedAutoPaymentSyncFlush(delay = 100) {
+    if (!this.queuedAutoPaymentSync) return;
+    if (this.autoPaymentSyncTimer) return;
+    this.autoPaymentSyncTimer = setTimeout(() => {
+      this.autoPaymentSyncTimer = null;
+      void this.flushQueuedAutoPaymentSync();
+    }, delay);
+  }
+  async flushQueuedAutoPaymentSync() {
+    if (!this.store.order) return;
+    if (!this.queuedAutoPaymentSync || this.autoPaymentSyncFlushing) return;
+    if (this.store.order.getOrderSyncState() === 'submitting') {
+      this.scheduleQueuedAutoPaymentSyncFlush();
+      return;
+    }
+    this.autoPaymentSyncFlushing = true;
+    try {
+      while (this.queuedAutoPaymentSync) {
+        this.queuedAutoPaymentSync = false;
+        const payments = this.store.order.getOrderPayments();
+        if (!payments.length) continue;
+        await this.syncPaymentsToOrder({
+          payments,
+          paymentStatus: this.getPaymentStatusForSync(payments),
+          submitWhenPaid: true,
+          smallTicketDataFlag: 1
+        });
+      }
+    } catch (error) {
+      this.logError('queued auto sync payments failed', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.autoPaymentSyncFlushing = false;
+      if (this.queuedAutoPaymentSync) {
+        this.scheduleQueuedAutoPaymentSyncFlush(0);
+      }
+    }
+  }
+
+  /** 追加单个支付项到当前订单。 */
+  addOrderPayment(payment) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const paymentRecord = payment;
+    const paymentAmount = new _decimal.default(paymentRecord.amount || 0);
+    if (paymentAmount.isZero()) {
+      this.logWarning('addOrderPayment: 支付金额为 0，跳过添加支付项', {
+        payment: paymentRecord
+      });
+      return this.store.order.getOrderPayments();
+    }
+    const metadata = paymentRecord.metadata && typeof paymentRecord.metadata === 'object' ? {
+      ...paymentRecord.metadata
+    } : {};
+    const shopWalletPassId = this.otherParams?.shop_wallet_pass_id;
+    if (shopWalletPassId !== undefined && shopWalletPassId !== null) {
+      metadata.shop_wallet_pass_id = shopWalletPassId;
+    }
+    if (!metadata.unique_payment_number) {
+      metadata.unique_payment_number = (0, _utils.createUuidV4)();
+    }
+    const paymentTimestamp = (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss');
+    const paymentTime = paymentRecord.payment_time ?? paymentTimestamp;
+    const createdAt = paymentRecord.created_at ?? paymentTimestamp;
+    const serviceCharge = paymentRecord.service_charge && typeof paymentRecord.service_charge === 'object' ? paymentRecord.service_charge : null;
+    const calculatedServiceFee = serviceCharge ? new _decimal.default(paymentRecord.origin_amount ?? paymentRecord.amount ?? 0).times(serviceCharge.percentage || 0).plus(serviceCharge.amount || 0).toDecimalPlaces(2).toFixed(2) : undefined;
+    const payments = this.store.order.addOrderPayment({
+      ...paymentRecord,
+      ...(calculatedServiceFee !== undefined ? {
+        service_fee: calculatedServiceFee
+      } : {}),
+      metadata,
+      payment_time: paymentTime,
+      created_at: createdAt
+    });
+    const amountSnapshot = this.store.order.getOrderAmountSnapshot();
+    const syncState = this.store.order.getOrderSyncState();
+    if (amountSnapshot) {
+      if (syncState === 'submitting') {
+        this.queueLatestAutoPaymentSync();
+        return payments;
+      }
+      void this.syncPaymentsToOrder({
+        payments,
+        paymentStatus: this.getPaymentStatusForSync(payments),
+        submitWhenPaid: true,
+        smallTicketDataFlag: 1
+      }).catch(error => {
+        this.logError('auto sync payments failed', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+    return payments;
+  }
+
+  /** 更新当前订单中的指定支付项。 */
+  updateOrderPayment(paymentIdentity, updates) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.updateOrderPayment(paymentIdentity, updates);
+  }
+
+  /** 删除当前订单中的指定支付项。 */
+  deleteOrderPayment(paymentIdentity) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.deleteOrderPayment(paymentIdentity);
+  }
+
+  /** 覆盖 wallet pass 支付项，同时保留普通支付项。 */
+  updateVoucherOrderPayments(payments, options) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.updateVoucherOrderPayments(payments, options);
+  }
+  confirmPendingVoucherPayments() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.confirmPendingVoucherPayments();
+  }
+  discardPendingVoucherPayments() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.discardPendingVoucherPayments();
+  }
+  getWalletProductList() {
+    const tempOrder = this.store.order?.getTempOrder();
+    if (!tempOrder?.products?.length) return [];
+    // 过滤出有 product_id的商品来，如果没有代表他是自定义商品，不需要参与 wallet
+    // debugger
+    // const products = tempOrder?.products?.filter(n => n.product_id)
+
+    const walletProducts = tempOrder?.products.map(product => {
+      const metadata = product.metadata || {};
+      const rawHolderId = product.holder_id ?? metadata.holder_id;
+      const holderIdValue = Array.isArray(rawHolderId) ? rawHolderId[0] : rawHolderId;
+      const holder_id = Number.isInteger(Number(holderIdValue)) ? Number(holderIdValue) : undefined;
+      return {
+        product_id: product.product_id || 0,
+        product_variant_id: String(product.product_variant_id ?? ''),
+        quantity: product.num || 1,
+        is_price_include_tax: tempOrder.is_price_include_tax,
+        is_charge_tax: product.is_charge_tax ?? 0,
+        tax_fee: product.tax_fee,
+        selling_price: Number(product.selling_price || 0),
+        discount_list: product.discount_list || [],
+        holder_id,
+        original_price: product.original_price,
+        main_product_original_price: metadata.main_product_original_price ?? product.original_price,
+        main_product_selling_price: metadata.main_product_selling_price ?? product.selling_price,
+        metadata: {
+          main_product_attached_bundle_tax_fee: metadata.main_product_attached_bundle_tax_fee,
+          main_product_attached_bundle_surcharge_fee: metadata.main_product_attached_bundle_surcharge_fee,
+          surcharge_rounding_remainder: metadata.surcharge_rounding_remainder
+        },
+        product_bundle: (product.product_bundle || []).map(bundle => {
+          const bundleMetadata = bundle.metadata || {};
+          return {
+            is_price_include_tax: tempOrder.is_price_include_tax,
+            // 套餐子项在 tempOrder 上常为 id（如 1718），prepare/deduction 协议要求 bundle_id
+            bundle_id: bundle.bundle_id ?? bundle.id,
+            bundle_product_id: bundle.bundle_product_id ?? bundle._bundle_product_id,
+            bundle_group_id: bundle.bundle_group_id ?? bundle.group_id,
+            bundle_variant_id: bundle.bundle_variant_id,
+            price_type: bundle.price_type,
+            price_type_ext: bundle.price_type_ext,
+            bundle_sum_price: bundle.bundle_sum_price,
+            bundle_selling_price: bundle.bundle_selling_price,
+            num: bundle.num,
+            is_charge_tax: bundle.is_charge_tax,
+            tax_fee: bundle.tax_fee,
+            metadata: {
+              surcharge_fee: bundleMetadata.surcharge_fee,
+              surcharge_rounding_remainder: bundleMetadata.surcharge_rounding_remainder
+            }
+          };
+        })
+      };
+    });
+    return walletProducts;
+  }
+  async initWalletData(params) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    if (!this.store.payment) throw new Error('payment 模块未初始化');
+    const snapshot = this.store.order.getOrderSnapshot();
+    const tempOrder = snapshot?.tempOrder;
+    const amount = snapshot?.amount;
+    if (!tempOrder || !amount) {
+      return {
+        walletRecommendList: [],
+        userIdentificationCodes: [],
+        transformList: [],
+        noApplicableVoucher: [],
+        products: []
+      };
+    }
+    const walletBusinessData = {
+      customer_id: tempOrder.customer_id ? Number(tempOrder.customer_id) : undefined,
+      holder: tempOrder.holder,
+      amountInfo: {
+        totalAmount: amount.totalAmount,
+        subTotal: amount.summary.product_amount || amount.summary.product_expect_amount || amount.totalAmount,
+        depositAmount: amount.depositAmount,
+        isDeposit: tempOrder.is_deposit
+      },
+      products: this.getWalletProductList(),
+      order_wait_pay_amount: params?.order_wait_pay_amount ?? Number(amount.amountGap || 0),
+      is_price_include_tax: tempOrder.is_price_include_tax ?? this.otherParams.is_price_include_tax ?? 1,
+      ...(snapshot.identity.orderId ? {
+        payment_order_id: String(snapshot.identity.orderId)
+      } : {})
+    };
+    const result = await this.store.payment.wallet.initializeWalletDataFromBusinessAsync(walletBusinessData);
+    await this.core.effects.emit(`${this.name}:onWalletDataInitialized`, {
+      orderId: snapshot.identity.orderId,
+      customerId: walletBusinessData.customer_id,
+      walletBusinessData: {
+        customer_id: walletBusinessData.customer_id,
+        amountInfo: walletBusinessData.amountInfo,
+        order_wait_pay_amount: walletBusinessData.order_wait_pay_amount
+      },
+      timestamp: Date.now()
+    });
+    return result;
+  }
+
+  /**
+   * 更新当前订单客户字段。
+   *
+   * 这是 PaymentModal 客户切换的订单事实入口；外部客户模块同步应由
+   * 调用方通过 onCustomerChange 回调完成。
+   */
+  updateOrderCustomer(customer) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    const result = this.store.order.updateTempOrderCustomer(customer);
+    this.store.order.recalculateSummary({
+      createIfMissing: true
+    });
+    this.store.order.persistTempOrder();
+    return result;
+  }
+
+  /** 获取可用支付方式列表，供 PaymentModal 渲染支付选项。 */
+  async getPaymentMethodsAsync() {
+    // if (this.store.payment) {
+    //   return this.store.payment.getPayMethodListAsync();
+    // }
+    try {
+      const response = await this.request.get('/pay/custom-payment/all', {
+        filterPaymentMethods: true
+      }, {
+        osServer: true
+      });
+      const paymentMethods = response?.data || [];
+      this.paymentMethodsCache = Array.isArray(paymentMethods) ? [...paymentMethods] : [];
+      return this.getPaymentMethods();
+    } catch (error) {
+      this.logWarning('getPaymentMethodsAsync: 获取支付方式列表失败，使用缓存列表', {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return this.getPaymentMethods();
+    }
+  }
+
+  /** 同步读取初始化时缓存的支付方式列表。 */
+  getPaymentMethods() {
+    return [...this.paymentMethodsCache];
+  }
+
+  /** 轻量舍入能力，供现金支付 UI 计算 rounding_amount。 */
+  roundAmount(params) {
+    const amount = new _decimal.default(params.amount || 0);
+    const interval = new _decimal.default(params.interval || 0.05);
+    const rule = params.rule || 'standard_rounding';
+    const quotient = amount.div(interval);
+    let roundedQuotient;
+    if (rule === 'always_up') {
+      roundedQuotient = quotient.ceil();
+    } else if (rule === 'always_down') {
+      roundedQuotient = quotient.floor();
+    } else if (rule === 'standard_down') {
+      roundedQuotient = quotient.toDecimalPlaces(0, _decimal.default.ROUND_HALF_DOWN);
+    } else {
+      roundedQuotient = quotient.toDecimalPlaces(0, _decimal.default.ROUND_HALF_UP);
+    }
+    const roundedAmount = roundedQuotient.times(interval).toDecimalPlaces(2);
+    return {
+      originalAmount: amount.toFixed(2),
+      roundedAmount: roundedAmount.toFixed(2),
+      roundingDifference: roundedAmount.minus(amount).toFixed(2)
+    };
+  }
+
+  /**
+   * 发送支付链接。
+   *
+   * 如果没有 orderIds 或显式 submitBeforeSend，会先提交当前本地订单到云端；
+   * 只有成功拿到远端 order_id 后才调用 OrderModule 发送邮件。
+   */
+  async sendCustomerPayLink(params) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    let orderIds = params.order_ids || params.orderIds || [];
+    if (!orderIds.length || params.submitBeforeSend) {
+      const submitResult = await this.submitSalesOrder({
+        smallTicketDataFlag: 1
+      });
+      const orderId = submitResult?.data?.order_id ?? submitResult?.order_id ?? submitResult?.data?.id ?? submitResult?.id;
+      if (!orderId) {
+        throw new Error('本地订单提交云端失败，无法发送支付链接');
+      }
+      orderIds = [orderId];
+    }
+    return this.store.order.sendCustomerPayLink({
+      emails: params.emails,
+      notify_action: params.notify_action,
+      order_ids: orderIds
+    });
+  }
+  transformBaseProductToOrderProduct(params) {
+    return (0, _transformBaseProductToOrderProduct.transformBaseProductToOrderProduct)(params);
+  }
+  async calculateProductBookingPrice(params) {
+    const quotation = this.store.quotation;
+    const customerId = params.customer_id ?? this.getCurrentOrderCustomerId();
+    const authoritativeProduct = await this.loadProductForPriceQuery(params, customerId);
+    const product = this.mergeProductForPriceQuery(params.product, authoritativeProduct);
+    await this.loadQuotationForPriceQuery({
+      quotation,
+      customer_id: customerId,
+      channel: params.channel
+    });
+    return (0, _quotationPrice.calculateBaseSalesProductBookingPrice)({
+      ...params,
+      product,
+      fallback_price: authoritativeProduct ? undefined : params.fallback_price,
+      customer_id: customerId,
+      quotation
+    });
+  }
+  getQuotationCustomerScopeInfo() {
+    const quotation = this.store.quotation;
+    if (quotation && typeof quotation.getQuotationCustomerScopeInfo === 'function') {
+      return quotation.getQuotationCustomerScopeInfo();
+    }
+    const list = typeof quotation?.getQuotationList === 'function' ? quotation.getQuotationList() : [];
+    const customerById = new Map();
+    const quotationScopes = (Array.isArray(list) ? list : []).filter(item => Array.isArray(item?.customer) && item.customer.length > 0).map(item => {
+      const localSeen = new Set();
+      const customers = item.customer.filter(customer => {
+        const customerId = this.normalizePriceContextCustomerId(customer?.id);
+        if (!customerId || localSeen.has(customerId)) return false;
+        localSeen.add(customerId);
+        if (!customerById.has(customerId)) customerById.set(customerId, customer);
+        return true;
+      });
+      return {
+        quotationId: item.id,
+        quotationName: item.name,
+        customerIds: customers.map(customer => String(customer.id)),
+        customers
+      };
+    });
+    return {
+      quotationCount: Array.isArray(list) ? list.length : 0,
+      hasCustomerScopedQuotations: quotationScopes.length > 0,
+      allQuotationsCustomerScoped: Array.isArray(list) && list.length > 0 && quotationScopes.length === list.length,
+      customerIds: Array.from(customerById.keys()),
+      customers: Array.from(customerById.values()),
+      quotationScopes
+    };
+  }
+  shouldRecalculateProductBookingPricesForContextChange(params) {
+    const scopeInfo = this.getQuotationCustomerScopeInfo();
+    const scopedCustomerIds = new Set(scopeInfo.customerIds.map(id => String(id)));
+    const previousCustomerId = this.normalizePriceContextCustomerId(params.previousCustomerId);
+    const nextCustomerId = this.normalizePriceContextCustomerId(params.nextCustomerId);
+    const previousInScope = previousCustomerId ? scopedCustomerIds.has(previousCustomerId) : false;
+    const nextInScope = nextCustomerId ? scopedCustomerIds.has(nextCustomerId) : false;
+    let shouldRecalculate = false;
+    if (scopeInfo.hasCustomerScopedQuotations) {
+      if (previousInScope) {
+        shouldRecalculate = true;
+      } else if (!previousCustomerId && !nextInScope) {
+        shouldRecalculate = false;
+      } else {
+        shouldRecalculate = nextInScope;
+      }
+    }
+    return shouldRecalculate;
+  }
+  async calculateProductBookingPrices(paramsList) {
+    if (!paramsList.length) return [];
+    const quotation = this.store.quotation;
+    const customerId = paramsList[0]?.customer_id ?? this.getCurrentOrderCustomerId();
+    const productMapsByGroup = new Map();
+    const groups = new Map();
+    paramsList.forEach(params => {
+      const product = params.product || {};
+      const productId = this.getPriceQueryProductId(product);
+      if (productId === null) return;
+      const schedule = this.getPriceQuerySchedule(params);
+      const channel = params.channel || this.otherParams?.channel;
+      const groupKey = [schedule.schedule_date, schedule.schedule_datetime, channel || ''].join('|');
+      const group = groups.get(groupKey) || {
+        ids: new Set(),
+        schedule,
+        channel
+      };
+      group.ids.add(productId);
+      groups.set(groupKey, group);
+    });
+    await Promise.all(Array.from(groups.entries()).map(async ([groupKey, group]) => {
+      const productsById = await this.loadProductsForPriceQuery({
+        ids: Array.from(group.ids),
+        schedule: group.schedule,
+        customerId,
+        channel: group.channel
+      });
+      productMapsByGroup.set(groupKey, productsById);
+    }));
+    await this.loadQuotationForPriceQuery({
+      quotation,
+      customer_id: customerId,
+      channel: paramsList[0]?.channel
+    });
+    return paramsList.map(params => {
+      const productInput = params.product || {};
+      const productId = this.getPriceQueryProductId(productInput);
+      const schedule = this.getPriceQuerySchedule(params);
+      const channel = params.channel || this.otherParams?.channel;
+      const groupKey = [schedule.schedule_date, schedule.schedule_datetime, channel || ''].join('|');
+      const authoritativeProduct = productId === null ? null : productMapsByGroup.get(groupKey)?.get(productId) || null;
+      const product = this.mergeProductForPriceQuery(productInput, authoritativeProduct);
+      return (0, _quotationPrice.calculateBaseSalesProductBookingPrice)({
+        ...params,
+        product,
+        fallback_price: authoritativeProduct ? undefined : params.fallback_price,
+        customer_id: customerId,
+        quotation
+      });
+    });
+  }
+  async addProductToOrder(product, booking) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const products = await this.store.order.addProductToOrder(product, booking);
+      // // 需要叠加
+      // if (this.hooks.onAddProductOverlay) {
+      //   const res = this.hooks.onAddProductOverlay(是否叠加, product)
+      //   if (!res) {
+      //     单独添加商品
+      //   } else {
+      //     叠加
+      //   }
+      // } else {
+      //   叠加
+      // }
+      return products;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async updateOrderProduct(params) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const products = await this.store.order.updateOrderProduct(params);
+      return products;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async updateOrderProducts(paramsList) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const products = await this.store.order.updateOrderProducts(paramsList);
+      return products;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async updateOrderProductQuantity(params) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      const products = await this.store.order.updateOrderProductQuantity(params);
+      return products;
+    } catch (error) {
+      throw error;
+    }
+  }
+  updateOrderBooking(params) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      return this.store.order.updateOrderBooking(params);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * 设置单行商品备注（与整单 `updateTempOrderNote` 区分）。
+   * 多行同 SKU 时必须传入与删除/更新一致的 unique_identification_number。
+   */
+  async setOrderProductLineNote(identity, note) {
+    try {
+      const params = {
+        product_id: identity.product_id,
+        product_variant_id: identity.product_variant_id,
+        updates: {
+          note: String(note || '')
+        }
+      };
+      if (identity.unique_identification_number !== undefined) {
+        params.unique_identification_number = identity.unique_identification_number;
+      }
+      if (identity.product_sku !== undefined) {
+        params.product_sku = identity.product_sku;
+      }
+      if (identity.product_bundle !== undefined) params.product_bundle = identity.product_bundle;
+      const products = await this.updateOrderProduct(params);
+      return products;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * 批量删除购物车行，末尾仅一次促销重算。
+   *
+   * @example
+   * await baseSales.removeProductsFromOrder([identityA, identityB]);
+   */
+  async removeProductsFromOrder(identities) {
+    try {
+      if (!this.store.order) throw new Error('order 模块未初始化');
+      return await this.store.order.removeProductsFromOrder(identities);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async removeProductFromOrder(identity) {
+    return this.removeProductsFromOrder([identity]);
+  }
+
+  // ─── 促销/赠品 透传（迁移自 booking usePromotion） ────────────────
+
+  /**
+   * 注入促销评估器到底层 OrderModule。
+   *
+   * @example
+   * solution.setPromotionEvaluator(appHelper.utils.promotionEvaluator);
+   */
+  setPromotionEvaluator(evaluator) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    this.store.order.setPromotionEvaluator(evaluator);
+  }
+
+  /**
+   * 注入赠品选择 resolver。UI 层（SalesSdk）通过 bridge 提供。
+   *
+   * @example
+   * solution.setGiftSelectResolver(async (ctx) => bridge.request(ctx));
+   */
+  setGiftSelectResolver(resolver) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    this.store.order.setGiftSelectResolver(resolver);
+  }
+
+  /**
+   * 为商品目录追加促销标签，供 SalesSdkProductProvider 等商品列表入口复用。
+   *
+   * @example
+   * const products = solution.appendPromotionTags(catalogProducts);
+   */
+  appendPromotionTags(products) {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    return this.store.order.appendPromotionTags(products);
+  }
+
+  /**
+   * 主动触发一次促销应用（一般写路径会自动触发，少数场景如客户切换后可手动调）。
+   */
+  async applyPromotion() {
+    if (!this.store.order) throw new Error('order 模块未初始化');
+    await this.store.order.applyPromotion();
+  }
+
+  /** 最近一次促销计算输出的未满足提示。 */
+  getUnfulfilledPromotions() {
+    return this.store.order?.getUnfulfilledPromotions() || [];
+  }
+
+  /** 最近一次促销计算输出的赠品操作 diff。 */
+  getLastGiftActions() {
+    return this.store.order?.getLastGiftActions() || null;
+  }
+
+  // 获取商品列表
+  // TODO 需要跟 webpos 内的对齐一下
+  async getProductList() {
+    // 可以直接通过配置里的 menu 读取
+    const menu_list_ids = this.otherParams?.dineInConfig?.['menu.associated_menus'].map(n => Number(n.value)) || [];
+    try {
+      const res = await this.store.products?.loadProducts({
+        menu_list_ids,
+        cacheId: this.cacheId,
+        schedule_date: (0, _dayjs.default)().format('YYYY-MM-DD'),
+        schedule_datetime: (0, _dayjs.default)().format('YYYY-MM-DD HH:mm:ss')
+      });
+      return res;
+    } catch (error) {
+      throw error;
+    }
+  }
+  getOtherParams() {
+    return this.otherParams;
+  }
+  async setOtherParams(params, {
+    cover = false
+  } = {}) {
+    if (cover) {
+      this.otherParams = {
+        ...params
+      };
+    } else {
+      this.otherParams = {
+        ...this.otherParams,
+        ...params
+      };
+    }
+    this.cacheId = this.otherParams?.cacheId;
+    await this.syncOtherParamsToSubModules(params, {
+      cover
+    });
+  }
+}
+exports.BaseSalesImpl = BaseSalesImpl;