@pisell/pisellos 0.10.20 → 0.10.22

package/lib/modules/Quotation/index.js

@@ -14,6 +14,11 @@ class QuotationModule extends _BaseModule.BaseModule {
     list: []
   };
   scheduleResolver;
+  quotationCache = new Map();
+  quotationLoadPromises = new Map();
+  quotationCacheVersions = new Map();
+  lifecycleGeneration = 0;
+  activeChannelKey = '';
   constructor(name, version) {
     super(name, version);
   }
@@ -24,20 +29,99 @@ class QuotationModule extends _BaseModule.BaseModule {
     this.store = {
       list: []
     };
+    this.quotationCache.clear();
+    this.quotationLoadPromises.clear();
+    this.quotationCacheVersions.clear();
+    this.activeChannelKey = '';
+    this.lifecycleGeneration += 1;
   }
   async loadQuotations(params) {
-    const query = {};
-    if (params?.channel) query.channel = params.channel;
-    if (params?.channel === 'online_store') {
-      query.channel = 'online-store';
+    const channelKey = this.normalizeChannel(params?.channel);
+    const cacheVersion = this.bumpQuotationCacheVersion(channelKey);
+    const lifecycleGeneration = this.lifecycleGeneration;
+    this.activateChannel(channelKey);
+    const loadPromise = this.fetchQuotations({
+      channelKey,
+      cacheVersion,
+      lifecycleGeneration
+    });
+    this.quotationLoadPromises.set(channelKey, loadPromise);
+    try {
+      await loadPromise;
+    } finally {
+      if (this.quotationLoadPromises.get(channelKey) === loadPromise) {
+        this.quotationLoadPromises.delete(channelKey);
+      }
     }
+  }
+  async ensureQuotations(params) {
+    const channelKey = this.normalizeChannel(params?.channel);
+    const lifecycleGeneration = this.lifecycleGeneration;
+    while (true) {
+      if (this.lifecycleGeneration !== lifecycleGeneration) return;
+      if (this.quotationCache.has(channelKey)) {
+        this.activateChannel(channelKey);
+        return;
+      }
+      const pending = this.quotationLoadPromises.get(channelKey);
+      if (!pending) {
+        try {
+          await this.loadQuotations(params);
+        } catch (error) {
+          if (this.quotationCache.has(channelKey)) {
+            this.activateChannel(channelKey);
+            return;
+          }
+          if (this.quotationLoadPromises.has(channelKey)) continue;
+          throw error;
+        }
+        continue;
+      }
+      const cacheVersion = this.getQuotationCacheVersion(channelKey);
+      try {
+        await pending;
+      } catch (error) {
+        const latestPending = this.quotationLoadPromises.get(channelKey);
+        if (latestPending && latestPending !== pending) continue;
+        if (this.getQuotationCacheVersion(channelKey) !== cacheVersion) continue;
+        throw error;
+      }
+      if (this.quotationCache.has(channelKey)) {
+        this.activateChannel(channelKey);
+        return;
+      }
+      const latestPending = this.quotationLoadPromises.get(channelKey);
+      if (latestPending && latestPending !== pending) continue;
+    }
+  }
+  invalidateQuotationCache(channel) {
+    if (channel !== undefined) {
+      const channelKey = this.normalizeChannel(channel);
+      this.bumpQuotationCacheVersion(channelKey);
+      this.quotationCache.delete(channelKey);
+      this.quotationLoadPromises.delete(channelKey);
+      if (this.activeChannelKey === channelKey) this.store.list = [];
+      return;
+    }
+    const channelKeys = new Set([...this.quotationCache.keys(), ...this.quotationLoadPromises.keys(), ...this.quotationCacheVersions.keys(), this.activeChannelKey]);
+    channelKeys.forEach(channelKey => this.bumpQuotationCacheVersion(channelKey));
+    this.quotationCache.clear();
+    this.quotationLoadPromises.clear();
+    this.store.list = [];
+  }
+  async fetchQuotations(params) {
+    const query = {};
+    if (params.channelKey) query.channel = params.channelKey;
     const res = await this.request.get('/quotation/available', query, {
       useCache: false,
       osServer: true
     });
-    const list = res?.data?.list || res?.list || [];
-    list.sort((a, b) => b.sort - a.sort);
-    this.store.list = list;
+    const list = [...(res?.data?.list || res?.list || [])].sort((a, b) => b.sort - a.sort);
+    if (this.lifecycleGeneration !== params.lifecycleGeneration || this.getQuotationCacheVersion(params.channelKey) !== params.cacheVersion) {
+      return;
+    }
+    this.quotationCache.set(params.channelKey, list);
+    if (this.activeChannelKey === params.channelKey) this.store.list = list;
   }
   getQuotationList() {
     return this.store.list;
@@ -93,7 +177,8 @@ class QuotationModule extends _BaseModule.BaseModule {
       datetime,
       customer_id
     } = params;
-    for (const quotation of this.store.list) {
+    const quotations = params.channel === undefined ? this.store.list : this.quotationCache.get(this.normalizeChannel(params.channel)) || [];
+    for (const quotation of quotations) {
       const visible = this.isQuotationVisibleForCustomer(quotation, customer_id);
       if (!visible) continue;
       const active = this.isQuotationActiveAt(quotation, datetime);
@@ -119,13 +204,15 @@ class QuotationModule extends _BaseModule.BaseModule {
    */
   buildProductPriceMap(params) {
     const map = new Map();
-    if (!this.store.list.length) return map;
+    const quotations = params.channel === undefined ? this.store.list : this.quotationCache.get(this.normalizeChannel(params.channel)) || [];
+    if (!quotations.length) return map;
     for (const productId of params.productIds) {
       for (const timePoint of params.timePoints) {
         const key = `${productId}:${timePoint}`;
         const price = this.getPriceForProduct({
           productId,
           datetime: timePoint,
+          channel: params.channel,
           customer_id: params.customer_id
         });
         if (price !== null) {
@@ -138,6 +225,22 @@ class QuotationModule extends _BaseModule.BaseModule {
   setScheduleResolver(resolver) {
     this.scheduleResolver = resolver;
   }
+  normalizeChannel(channel) {
+    const normalized = channel?.trim().toLowerCase() || '';
+    return normalized === 'online_store' ? 'online-store' : normalized;
+  }
+  activateChannel(channelKey) {
+    this.activeChannelKey = channelKey;
+    this.store.list = this.quotationCache.get(channelKey) || [];
+  }
+  getQuotationCacheVersion(channelKey) {
+    return this.quotationCacheVersions.get(channelKey) || 0;
+  }
+  bumpQuotationCacheVersion(channelKey) {
+    const nextVersion = this.getQuotationCacheVersion(channelKey) + 1;
+    this.quotationCacheVersions.set(channelKey, nextVersion);
+    return nextVersion;
+  }
   isQuotationVisibleForCustomer(quotation, customerId) {
     const customers = quotation.customer || [];
     if (customers.length === 0) return true;

package/lib/modules/ResourcePlanner/planner.d.ts

@@ -1,5 +1,5 @@
-import type { AvailabilityProjection, AvailabilityProjectionInput, AvailabilityQuery, AvailabilityQueryResult, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, GetProductTimeRangesRequest, ProductTimeRangeGroup } from './types';
+import type { AvailabilityProjection, AvailabilityProjectionInput, AvailabilityQuery, AvailabilityQueryResult, AvailabilitySelectionValidationParams, AvailabilitySelectionValidationResult, GetProductTimeRangesRequest, GetProductTimeRangesRuntimeOptions, ProductTimeRangeGroup } from './types';
 export declare function createAvailabilityProjection(input: AvailabilityProjectionInput): AvailabilityProjection;
-export declare function getProductTimeRanges(projection: AvailabilityProjection, request?: GetProductTimeRangesRequest): ProductTimeRangeGroup[];
+export declare function getProductTimeRanges(projection: AvailabilityProjection, request?: GetProductTimeRangesRequest, runtimeOptions?: GetProductTimeRangesRuntimeOptions): ProductTimeRangeGroup[];
 export declare function queryAvailabilityProjection(projection: AvailabilityProjection, request: AvailabilityQuery): AvailabilityQueryResult;
 export declare function validateAvailabilitySelection(projection: AvailabilityProjection, params: AvailabilitySelectionValidationParams): AvailabilitySelectionValidationResult;

package/lib/modules/ResourcePlanner/planner.js

@@ -11,8 +11,8 @@ var _types = require("./types");
 var _localClock = require("./localClock");
 const DEFAULT_SLOT_STEP_MINUTES = 30;
 const DEFAULT_BUSINESS_HOURS = {
-  startTime: '09:00',
-  endTime: '18:00'
+  startTime: '00:00',
+  endTime: '00:00'
 };
 function availabilityError(code, message, details) {
   return new _types.AvailabilityError(code, message, details);
@@ -48,6 +48,19 @@ function normalizeBookingCount(bookingCount) {
   }
   return normalized;
 }
+function resolveRequestedDurationMinutes(product, request) {
+  const configured = Math.max(1, Number(product.durationMinutes || 30) || 30);
+  if (product.kind !== 'duration') return configured;
+  const override = request.durationMinutesByProductId?.[String(product.id)];
+  const normalized = Number(override);
+  return Number.isInteger(normalized) && normalized > 0 ? normalized : configured;
+}
+function resolveRequestedDurationStartTimes(product, request) {
+  if (product.kind !== 'duration') return [];
+  const values = request.durationStartTimesByProductId?.[String(product.id)];
+  if (!Array.isArray(values)) return [];
+  return Array.from(new Set(values.filter(value => typeof value === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/.test(value))));
+}
 function toDateTime(value, _timezoneName) {
   try {
     return (0, _localClock.localDateTimeToScalar)((0, _localClock.parseLocalDateTime)(value));
@@ -75,6 +88,9 @@ function addMinutesZoned(value, minutes, _timezoneName) {
 function ceilToTenMinutes(value, _timezoneName) {
   return (0, _localClock.ceilLocalScalarToTenMinutes)(value);
 }
+function floorToMinute(value) {
+  return Math.floor(value / 60000) * 60000;
+}
 function nextDate(value, _timezoneName) {
   return (0, _localClock.nextDate)(value);
 }
@@ -865,9 +881,30 @@ function dedupeProductRanges(ranges) {
   });
   return Array.from(map.values()).sort((left, right) => left.startAt.localeCompare(right.startAt));
 }
-function getProductTimeRanges(projection, request = {}) {
+function createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes) {
+  const bookingEnd = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+  return createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes);
+}
+function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection, fixedOffsetMinutes) {
+  return {
+    key: `${String(product.id)}:${start}:${bookingEnd}`,
+    productId: product.id,
+    source: 'duration_window',
+    startAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    bookingStartAt: formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes),
+    bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
+    date: formatDate(start, projection.meta.timezone),
+    startTime: formatTime(start, projection.meta.timezone),
+    endTime: formatTime(bookingEnd, projection.meta.timezone),
+    timezone: projection.meta.timezone,
+    scheduleRefs: []
+  };
+}
+function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
   const normalizedPartySize = normalizePartySize(request.partySize);
   const dateRange = resolveProjectionDateRange(projection, request.dateRange);
+  const slotStepMinutes = projection.meta.defaults.slotStepMinutes;
   const fixedOffsetMinutes = (0, _localClock.extractFixedOffsetMinutes)(projection.meta.now) ?? (0, _localClock.captureRuntimeOffsetMinutes)();
   const resourceWindowIndex = buildResourceWindowIndex(projection);
   const filteredProductIdSet = request.productIds?.length ? new Set(request.productIds.map(String)) : null;
@@ -877,6 +914,7 @@ function getProductTimeRanges(projection, request = {}) {
         productId: product.id,
         title: product.title,
         kind: product.kind,
+        slotStepMinutes,
         ranges: []
       };
     }
@@ -885,6 +923,7 @@ function getProductTimeRanges(projection, request = {}) {
         productId: product.id,
         title: product.title,
         kind: product.kind,
+        slotStepMinutes,
         ranges: getSessionRangesForProduct(projection, product, dateRange)
       };
     }
@@ -900,11 +939,30 @@ function getProductTimeRanges(projection, request = {}) {
       resourceWindowIndex
     })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
     const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
-    const durationMinutes = Math.max(1, Number(product.durationMinutes || 30) || 30);
-    const timeSliceMinutes = projection.meta.defaults.slotStepMinutes;
+    const durationMinutes = resolveRequestedDurationMinutes(product, request);
+    const flexibleStartAt = (() => {
+      if (!product.isFlexibleDuration) return undefined;
+      const evaluatedAt = toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt, projection.meta.timezone);
+      if (!Number.isFinite(evaluatedAt)) {
+        throw availabilityError('INVALID_TARGET_FILTER', 'runtimeOptions.evaluatedAt 必须是有效时间', {
+          evaluatedAt: runtimeOptions.evaluatedAt
+        });
+      }
+      return floorToMinute(evaluatedAt);
+    })();
     const durationAnchor = ceilToTenMinutes(toDateTime(projection.meta.durationCandidateAnchorAt, projection.meta.timezone), projection.meta.timezone);
+    const requestedStartTimes = resolveRequestedDurationStartTimes(product, request);
     const ranges = [];
     baseRanges.forEach(range => {
+      if (product.isFlexibleDuration && flexibleStartAt !== undefined) {
+        const start = Math.max(range.start, flexibleStartAt);
+        if (start >= range.end) return;
+        const bookingDate = formatDate(start);
+        if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
+          ranges.push(createDurationTimeRangeWithEnd(product, start, range.end, projection, fixedOffsetMinutes));
+        }
+        return;
+      }
       if (range.end <= durationAnchor) return;
       let cursor = range.start;
       if (cursor < durationAnchor) {
@@ -915,28 +973,28 @@ function getProductTimeRanges(projection, request = {}) {
         if (bookingEnd > range.end) break;
         const bookingDate = formatDate(cursor);
         if (bookingDate >= dateRange.startDate && bookingDate <= dateRange.endDate) {
-          ranges.push({
-            key: `${String(product.id)}:${cursor}:${bookingEnd}`,
-            productId: product.id,
-            source: 'duration_window',
-            startAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
-            endAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
-            bookingStartAt: formatDateTime(cursor, projection.meta.timezone, fixedOffsetMinutes),
-            bookingEndAt: formatDateTime(bookingEnd, projection.meta.timezone, fixedOffsetMinutes),
-            date: formatDate(cursor, projection.meta.timezone),
-            startTime: formatTime(cursor, projection.meta.timezone),
-            endTime: formatTime(bookingEnd, projection.meta.timezone),
-            timezone: projection.meta.timezone,
-            scheduleRefs: []
-          });
+          ranges.push(createDurationTimeRange(product, cursor, durationMinutes, projection, fixedOffsetMinutes));
         }
-        cursor = addMinutesZoned(cursor, timeSliceMinutes, projection.meta.timezone);
+        cursor = addMinutesZoned(cursor, slotStepMinutes, projection.meta.timezone);
       }
     });
+    if (dateRange.startDate === dateRange.endDate && requestedStartTimes.length > 0) {
+      requestedStartTimes.forEach(startTime => {
+        const start = toDateTimeInDate(dateRange.startDate, startTime, projection.meta.timezone);
+        if (!Number.isFinite(start)) return;
+        const end = addMinutesZoned(start, durationMinutes, projection.meta.timezone);
+        const startsInOperatingRange = operatingRanges.some(range => range.start <= start && start < range.end);
+        if (!startsInOperatingRange && !request.allowOutsideOperatingHoursForRequestedStartTimes) {
+          return;
+        }
+        ranges.push(createDurationTimeRange(product, start, durationMinutes, projection, fixedOffsetMinutes));
+      });
+    }
     return {
       productId: product.id,
       title: product.title,
       kind: product.kind,
+      slotStepMinutes,
       ranges: dedupeProductRanges(ranges)
     };
   });
@@ -1560,6 +1618,8 @@ function queryAvailabilityProjection(projection, request) {
     dateRange,
     resourceIds: request.resourceIds,
     partySize: normalizedPartySize
+  }, {
+    evaluatedAt
   });
   const candidateGroupMap = new Map(candidateGroups.map(group => [String(group.productId), group]));
   if (request.target === 'date') {

package/lib/modules/ResourcePlanner/types.d.ts

@@ -81,6 +81,7 @@ export interface AvailabilityProduct {
     id: AvailabilityId;
     title?: string;
     kind: AvailabilityProductKind;
+    isFlexibleDuration?: boolean;
     durationMinutes?: number;
     quantity?: number;
     capacityRequired?: number;
@@ -211,6 +212,7 @@ export interface ProductTimeRangeGroup {
     productId: AvailabilityId;
     title?: string;
     kind: AvailabilityProductKind;
+    slotStepMinutes?: number;
     ranges: ProductTimeRange[];
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
@@ -231,6 +233,16 @@ export interface GetProductTimeRangesRequest {
     dateRange?: Partial<AvailabilityDateRange>;
     resourceIds?: AvailabilityId[];
     partySize?: number;
+    durationMinutesByProductId?: Record<string, number>;
+    durationStartTimesByProductId?: Record<string, string[]>;
+    /**
+     * POS 手工输入时间的兼容开关：只为明确请求的 start time 补候选，
+     * 不改变常规候选列表仍按营业时间生成的规则。
+     */
+    allowOutsideOperatingHoursForRequestedStartTimes?: boolean;
+}
+export interface GetProductTimeRangesRuntimeOptions {
+    evaluatedAt?: string;
 }
 export interface QueryAvailabilityBaseRequest {
     productIds?: AvailabilityId[];

package/lib/modules/Rules/index.d.ts

@@ -14,6 +14,11 @@ export declare class RulesModule extends BaseModule implements Module, RulesModu
     setRulesList(rulesList: Rules[]): Promise<void>;
     getRulesList(): Rules[];
     getWalletPassEvaluator(): import("../..").WalletPassEvaluator | undefined;
+    private normalizeHolderRecordIds;
+    /**
+     * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+     * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+     */
     private checkHolderMatch;
     isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, orderTotalAmount, holders, isFormSubject, }: {
         oldDiscountList: Discount[];

package/lib/modules/Rules/index.js

@@ -38,21 +38,30 @@ class RulesModule extends _BaseModule.BaseModule {
   getWalletPassEvaluator() {
     return this.window.getWalletPassEvaluator?.();
   }
+  normalizeHolderRecordIds(value) {
+    const records = Array.isArray(value) ? value : [value];
+    return Array.from(new Set(records.map(record => {
+      if (record && typeof record === 'object') {
+        return record.form_record_id;
+      }
+      return record;
+    }).filter(record => record !== undefined && record !== null && record !== '' && record !== 0 && record !== '0').map(String)));
+  }
 
-  // 商品不需要holder,则不需要判断，直接返回true，商品需要holder但是还没填写，那么暂时不使用带有holder的券，直到填写才去匹配
+  /**
+   * 特定 form Holder 卡只授权给绑定同一 Holder Record 的商品行。
+   * required/isNeedHolder 仅控制是否强制选择 Holder，不参与优惠资格。
+   */
   checkHolderMatch(discount, product, holders) {
     // 非表单类型 holder 视为匹配
     if (discount.holder?.holder_type !== 'form') return true;
-    // 主预约holder, 目前（20251124）默认只考虑单个holder的情况
-    // 旧版 holders[0].form_record_id 新版 holders[0]
-    const orderHolderId = Array.isArray(holders) && holders.length > 0 ? holders[0].form_record_id || holders[0] : undefined;
-    const productHolderId = Array.isArray(product.holder_id) ? product.holder_id[0] : product.holder_id;
-    // 商品不需要选holder，则不对比holder，直接返回true，
-    if (!product.isNeedHolder) return true;
-    // 商品需要holder，但父预约及商品都无holder，返回false
-    if (!orderHolderId && !productHolderId) return false;
-    // 最终直接匹配 holder 是否相同
-    return (productHolderId || orderHolderId) === discount.holder.holder_id;
+    const discountHolderIds = this.normalizeHolderRecordIds(discount.holder.holder_id);
+    if (!discountHolderIds.length) return false;
+    const productHolderIds = this.normalizeHolderRecordIds(product.holder_id);
+    const candidateHolderIds = productHolderIds.length ? productHolderIds : this.normalizeHolderRecordIds(holders);
+    if (!candidateHolderIds.length) return false;
+    const discountHolderIdSet = new Set(discountHolderIds);
+    return candidateHolderIds.some(holderId => discountHolderIdSet.has(holderId));
   }
 
   // 判断discountList 是否可以对当前productList生效

package/lib/plugins/request.d.ts

@@ -69,6 +69,7 @@ export interface RequestOptions {
     customToast?: () => void;
     cache?: CacheProps;
     osServer?: boolean;
+    isNocobase?: boolean;
     prefix?: boolean;
     callback?: (res: any) => void;
     subscriberId?: string;
@@ -124,7 +125,7 @@ declare class RequestPluginImpl implements RequestPlugin {
     /**
      * GET 请求
      */
-    get<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    get<T = any>(url: string, dataOrOptions?: any, options?: RequestOptions): Promise<T>;
     /**
      * POST 请求
      */

package/lib/plugins/request.js

@@ -99,9 +99,10 @@ class RequestPluginImpl {
   /**
    * GET 请求
    */
-  get(url, options = {}) {
+  get(url, dataOrOptions = {}, options) {
+    const requestOptions = options ?? dataOrOptions;
     return this.request({
-      ...options,
+      ...requestOptions,
       url,
       method: 'GET'
     });

package/lib/server/index.js

@@ -4720,7 +4720,22 @@ class Server {
     if (!this.shouldBuildSmallTicketData(order)) return order;
     if (options?.requireFullyPaid && !this.isSalesOrderFullyPaid(order)) return order;
     try {
-      const enrichedOrder = await this.enrichPaymentNamesByCode(order);
+      const normalizedCollections = (0, _orderCollectionIdentity.normalizeOrderCollections)(order, {
+        ensureUid: false
+      });
+      const normalizedOrder = normalizedCollections.order;
+      const collapsedDuplicateCounts = {
+        products: normalizedCollections.stats.product.collapsedDuplicateCount,
+        bookings: normalizedCollections.stats.booking.collapsedDuplicateCount,
+        payments: normalizedCollections.stats.payment.collapsedDuplicateCount
+      };
+      if (Object.values(collapsedDuplicateCounts).some(count => count > 0)) {
+        this.logWarning('withLocalSmallTicketData: 折叠重复订单子项', {
+          order_identifier: normalizedOrder.order_id ?? normalizedOrder.external_sale_number ?? normalizedOrder.shop_order_number ?? null,
+          collapsed_duplicate_counts: collapsedDuplicateCounts
+        });
+      }
+      const enrichedOrder = await this.enrichPaymentNamesByCode(normalizedOrder);
       const productMap = options?.productMap ?? (await this.buildSmallTicketProductMap(enrichedOrder));
       const smallTicketData = (0, _smallTicket.buildSmallTicketData)({
         order: enrichedOrder,

package/lib/solution/BaseSales/index.d.ts

@@ -129,8 +129,23 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
      */
     protected preferAuthoritativeProductQueryPrice(): boolean;
     private getPriceQuerySchedule;
+    private isCustomerUserPriceQuery;
+    private getPriceQueryScheduleList;
+    private buildPriceQueryPayload;
+    private getRawProductPriceSources;
+    private rememberRawProductPriceSources;
+    private getSelectedProductVariantId;
+    /**
+     * 将目录原始商品还原为本次选择的 SKU 基线。
+     *
+     * 这里绝不能复用已评估后的目录商品，否则从命中智能价切回不命中的
+     * 日期时会残留旧价格。套餐仅验证所选关系存在，最终仍由 merge 方法把
+     * 评估后的套餐价格映射回用户的选择数据。
+     */
+    private prepareRawProductForPriceQuery;
+    private resolveLocalProductForPriceQuery;
     private loadProductsForPriceQuery;
-    private loadProductForPriceQuery;
+    private resolveProductsForPriceQuery;
     private getAuthoritativeBundleItems;
     private findAuthoritativeBundleItem;
     private getAuthoritativeBundleUnitPrice;