@pisell/pisellos 2.3.80 → 2.3.82

package/dist/solution/BookingByStep/index.d.ts

@@ -326,7 +326,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 1 | 5 | 2 | 3 | 4 | 6;
+        weekNum: 0 | 1 | 2 | 3 | 4 | 5 | 6;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/dist/solution/BookingTicket/index.d.ts

@@ -334,7 +334,7 @@ export declare class BookingTicketImpl extends BaseSalesImpl implements Module {
      * 获取当前的客户搜索条件
      * @returns 当前搜索条件
      */
-    getCurrentCustomerSearchParams(): Omit<import("../../modules").ShopGetCustomerListParams, "num" | "skip">;
+    getCurrentCustomerSearchParams(): Omit<import("../../modules").ShopGetCustomerListParams, "skip" | "num">;
     /**
      * 获取客户列表状态（包含滚动加载相关状态）
      * @returns 客户状态

package/dist/solution/UnifiedBookingSales/index.js

@@ -42,6 +42,7 @@ import { UnifiedBookingSalesHooks } from "./types";
 import { AvailabilityRemoteOccupancyCache } from "./remoteOccupancyCache";
 import { BookingTicket } from "../BookingTicket";
 import { addLocalCalendarDays, captureRuntimeOffsetMinutes, formatLocalDate, formatLocalDateTime, formatLocalTime, localDateTimeToScalar, localDateToScalar, localDateToScalarStart, parseLocalDate, parseLocalDateTime } from "../../modules/ResourcePlanner/localClock";
+import { isCustomerUserPlatform } from "../../utils/platform";
 export * from "./types";
 export { AvailabilityError } from "../../modules/ResourcePlanner";
 var OPEN_DATA_SECTION_CODES = ['sale', 'reservation', 'fulfillment', 'menu', 'workflow', 'basic', 'checkout', 'availability'];
@@ -1950,8 +1951,7 @@ export var UnifiedBookingSalesImpl = /*#__PURE__*/function (_BookingTicket) {
     key: "isAuthenticatedCustomerUserPlatform",
     value: function isAuthenticatedCustomerUserPlatform() {
       var _this$otherParams14;
-      var platform = String(((_this$otherParams14 = this.otherParams) === null || _this$otherParams14 === void 0 ? void 0 : _this$otherParams14.platform) || '').toLowerCase();
-      return platform === 'pc' || platform === 'h5';
+      return isCustomerUserPlatform((_this$otherParams14 = this.otherParams) === null || _this$otherParams14 === void 0 ? void 0 : _this$otherParams14.platform);
     }
   }, {
     key: "resolveDiscountOrderIdentity",

package/dist/utils/platform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Normalize the runtime platform passed through solution/module otherParams.
+ */
+export declare function normalizeRuntimePlatform(platform: unknown): string;
+/**
+ * PC and H5 are authenticated-customer clients rather than staff terminals.
+ */
+export declare function isCustomerUserPlatform(platform: unknown): boolean;

package/dist/utils/platform.js

@@ -0,0 +1,15 @@
+var CUSTOMER_USER_PLATFORMS = new Set(['pc', 'h5']);
+
+/**
+ * Normalize the runtime platform passed through solution/module otherParams.
+ */
+export function normalizeRuntimePlatform(platform) {
+  return String(platform !== null && platform !== void 0 ? platform : '').trim().toLowerCase();
+}
+
+/**
+ * PC and H5 are authenticated-customer clients rather than staff terminals.
+ */
+export function isCustomerUserPlatform(platform) {
+  return CUSTOMER_USER_PLATFORMS.has(normalizeRuntimePlatform(platform));
+}

package/lib/modules/ProductList/clientDataVariants.d.ts

@@ -0,0 +1,50 @@
+import type { PisellCore } from '../../types';
+import type { RequestPlugin } from '../../plugins';
+import type { ProductData } from '../Product/types';
+export declare const PRODUCT_QUERY_DATA_VARIANT_RELATIONS: readonly ["category", "collection", "resourceRelation", "bundleGroup.bundleItem", "optionGroup.optionItem", "variantGroup.variantItem", "dataVariants"];
+/**
+ * 判断当前商品查询是否会被本地 OS Server 接管。
+ *
+ * H5 RequestPlugin 即使收到 osServer=true 仍会直接请求远端接口，因此必须按
+ * RequestPlugin 实际 baseUrl 对应的已注册路由判断，不能只看请求选项。
+ */
+export declare function isProductQueryHandledByOsServer(core: PisellCore | undefined, request: RequestPlugin | undefined): boolean;
+export interface ResolveClientDataVariantsParams {
+    core: PisellCore | undefined;
+    otherParams?: Record<string, any>;
+    products: ProductData[];
+    queryPayload: Record<string, any>;
+    handledByOsServer: boolean;
+    scheduleList?: unknown;
+    menuList?: unknown;
+    /** Quote fast paths require hydrated relations; legacy list resolution does not. */
+    requireCompleteDataVariantRelations?: boolean;
+    /** Quote fast paths require every referenced rule; legacy list resolution is best-effort. */
+    requireEvaluatorReady?: boolean;
+}
+export type ResolveClientDataVariantsResult = {
+    status: 'handled-by-os-server' | 'empty' | 'data-variants-unavailable' | 'evaluator-unavailable' | 'evaluator-not-ready';
+    products: ProductData[];
+} | {
+    status: 'resolved';
+    products: ProductData[];
+} | {
+    status: 'error';
+    products: ProductData[];
+    error: unknown;
+};
+/**
+ * Strict client-side Data Variant resolution for quote fast paths.
+ *
+ * Unlike resolveClientDataVariants, callers can distinguish a complete local
+ * result from a capability/readiness/error fallback and decide to query the
+ * remote product endpoint instead.
+ */
+export declare function tryResolveClientDataVariants({ core, otherParams, products, queryPayload, handledByOsServer, scheduleList: explicitScheduleList, menuList: explicitMenuList, requireCompleteDataVariantRelations, requireEvaluatorReady, }: ResolveClientDataVariantsParams): ResolveClientDataVariantsResult;
+/**
+ * 未启用商品 OS 路由时，在客户端补做 Data Variant 解析。
+ *
+ * 商品列表和预约报价必须共用这个边界，避免 H5 的弹窗报价绕过客户端智能定价。
+ * OS Server 已接管时直接信任服务端结果，确保同一批商品只评估一次。
+ */
+export declare function resolveClientDataVariants({ core, otherParams, products, queryPayload, handledByOsServer, scheduleList: explicitScheduleList, menuList: explicitMenuList, }: ResolveClientDataVariantsParams): ProductData[];

package/lib/modules/ProductList/clientDataVariants.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PRODUCT_QUERY_DATA_VARIANT_RELATIONS = void 0;
+exports.isProductQueryHandledByOsServer = isProductQueryHandledByOsServer;
+exports.resolveClientDataVariants = resolveClientDataVariants;
+exports.tryResolveClientDataVariants = tryResolveClientDataVariants;
+const PRODUCT_QUERY_DATA_VARIANT_RELATIONS = exports.PRODUCT_QUERY_DATA_VARIANT_RELATIONS = ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem', 'dataVariants'];
+
+/**
+ * 判断当前商品查询是否会被本地 OS Server 接管。
+ *
+ * H5 RequestPlugin 即使收到 osServer=true 仍会直接请求远端接口，因此必须按
+ * RequestPlugin 实际 baseUrl 对应的已注册路由判断，不能只看请求选项。
+ */
+function isProductQueryHandledByOsServer(core, request) {
+  const server = core?.server;
+  if (!server || typeof server.hasRoute !== 'function') return false;
+  const requestBaseUrl = String(request?.baseUrl || '/shop').replace(/\/+$/, '');
+  return server.hasRoute('post', `${requestBaseUrl}/product/query`) === true;
+}
+function getBundleItems(product) {
+  if (!Array.isArray(product.bundle_group)) return [];
+  return product.bundle_group.flatMap(group => Array.isArray(group?.bundle_item) ? group.bundle_item : []);
+}
+function hasCompleteDataVariantRelations(products) {
+  return products.every(product => Array.isArray(product?.data_variants));
+}
+function hasAnyDataVariants(products) {
+  return products.some(product => (product.data_variants?.length || 0) > 0 || getBundleItems(product).some(item => Array.isArray(item?.data_variants) && item.data_variants.length > 0));
+}
+function collectReferencedRuleIds(products) {
+  const ids = new Set();
+  const remember = variants => {
+    if (!Array.isArray(variants)) return;
+    variants.forEach(variant => {
+      const id = String(variant?.data_variant_rule_id ?? '').trim();
+      if (id) ids.add(id);
+    });
+  };
+  products.forEach(product => {
+    remember(product.data_variants);
+    getBundleItems(product).forEach(item => remember(item?.data_variants));
+  });
+  return ids;
+}
+function isEvaluatorReady(evaluator, products) {
+  if (typeof evaluator.isReady === 'function') {
+    if (evaluator.isReady() === false) return false;
+  }
+  if (evaluator.isReady === false || evaluator.ready === false) return false;
+
+  // The built-in evaluator is installed before its strategy request completes.
+  // A referenced Data Variant cannot be evaluated authoritatively until those
+  // configs have arrived. Evaluators without this capability remain compatible.
+  if (typeof evaluator.getStrategyConfigs === 'function') {
+    const configs = evaluator.getStrategyConfigs();
+    if (!Array.isArray(configs) || configs.length === 0) return false;
+    const availableRuleIds = new Set(configs.map(config => String(config?.metadata?.id ?? '').trim()).filter(Boolean));
+    return Array.from(collectReferencedRuleIds(products)).every(id => availableRuleIds.has(id));
+  }
+  return true;
+}
+
+/**
+ * Strict client-side Data Variant resolution for quote fast paths.
+ *
+ * Unlike resolveClientDataVariants, callers can distinguish a complete local
+ * result from a capability/readiness/error fallback and decide to query the
+ * remote product endpoint instead.
+ */
+function tryResolveClientDataVariants({
+  core,
+  otherParams = {},
+  products,
+  queryPayload,
+  handledByOsServer,
+  scheduleList: explicitScheduleList,
+  menuList: explicitMenuList,
+  requireCompleteDataVariantRelations = true,
+  requireEvaluatorReady = true
+}) {
+  if (handledByOsServer) {
+    return {
+      status: 'handled-by-os-server',
+      products
+    };
+  }
+  if (products.length === 0) {
+    return {
+      status: 'empty',
+      products
+    };
+  }
+  if (requireCompleteDataVariantRelations && !hasCompleteDataVariantRelations(products)) {
+    return {
+      status: 'data-variants-unavailable',
+      products
+    };
+  }
+
+  // Explicit empty arrays mean the query hydrated the relation and there is no
+  // rule to apply. This is an authoritative local base-price result even when
+  // no evaluator has been installed.
+  if (!hasAnyDataVariants(products)) {
+    return {
+      status: 'resolved',
+      products
+    };
+  }
+  const evaluator = core?.context?.dataVariantEvaluator;
+  if (!evaluator || typeof evaluator.resolveProducts !== 'function') {
+    return {
+      status: 'evaluator-unavailable',
+      products
+    };
+  }
+  try {
+    if (requireEvaluatorReady && !isEvaluatorReady(evaluator, products)) {
+      return {
+        status: 'evaluator-not-ready',
+        products
+      };
+    }
+  } catch (error) {
+    return {
+      status: 'error',
+      products,
+      error
+    };
+  }
+  const strategyContext = queryPayload.strategy_context && typeof queryPayload.strategy_context === 'object' ? queryPayload.strategy_context : {};
+  const fatherModule = String(otherParams.fatherModule || '').trim();
+  const scheduleModule = (fatherModule ? core?.getModule(`${fatherModule}_schedule`) : null) || core?.getModule('schedule');
+  const moduleScheduleList = scheduleModule?.getScheduleList?.();
+  const contextScheduleList = core?.context?.scheduleList;
+  const contextMenuList = core?.context?.menuList;
+  const businessData = {
+    products,
+    scheduleDateTime: queryPayload.schedule_datetime || queryPayload.schedule_date,
+    scheduleList: Array.isArray(explicitScheduleList) && explicitScheduleList.length > 0 ? explicitScheduleList : Array.isArray(moduleScheduleList) && moduleScheduleList.length > 0 ? moduleScheduleList : Array.isArray(contextScheduleList) ? contextScheduleList : [],
+    menuList: Array.isArray(explicitMenuList) ? explicitMenuList : Array.isArray(otherParams.menuList) ? otherParams.menuList : Array.isArray(contextMenuList) ? contextMenuList : [],
+    customerId: queryPayload.customer_id,
+    channel: strategyContext.channel,
+    orderType: strategyContext.orderType || strategyContext.order_type,
+    businessCode: strategyContext.business_code ?? strategyContext.businessCode,
+    availableWalletIds: strategyContext.available_wallet_ids,
+    custom: strategyContext
+  };
+  try {
+    const result = evaluator.resolveProducts(businessData);
+    if (!Array.isArray(result?.products)) {
+      return {
+        status: 'error',
+        products,
+        error: new Error('Data Variant evaluator returned an invalid product list')
+      };
+    }
+    return {
+      status: 'resolved',
+      products: result.products
+    };
+  } catch (error) {
+    return {
+      status: 'error',
+      products,
+      error
+    };
+  }
+}
+
+/**
+ * 未启用商品 OS 路由时，在客户端补做 Data Variant 解析。
+ *
+ * 商品列表和预约报价必须共用这个边界，避免 H5 的弹窗报价绕过客户端智能定价。
+ * OS Server 已接管时直接信任服务端结果，确保同一批商品只评估一次。
+ */
+function resolveClientDataVariants({
+  core,
+  otherParams = {},
+  products,
+  queryPayload,
+  handledByOsServer,
+  scheduleList: explicitScheduleList,
+  menuList: explicitMenuList
+}) {
+  const result = tryResolveClientDataVariants({
+    core,
+    otherParams,
+    products,
+    queryPayload,
+    handledByOsServer,
+    scheduleList: explicitScheduleList,
+    menuList: explicitMenuList,
+    requireCompleteDataVariantRelations: false,
+    requireEvaluatorReady: false
+  });
+  if (result.status === 'error') {
+    console.error('[ClientDataVariants] Data Variant 客户端解析失败', result.error);
+  }
+  return result.products;
+}

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

@@ -9,6 +9,7 @@ export declare class ProductList extends BaseModule implements Module {
     private store;
     private request;
     private otherParams;
+    private rawProductPriceSources;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: any): Promise<void>;
     /**
@@ -18,19 +19,6 @@ export declare class ProductList extends BaseModule implements Module {
      * productList.updateOtherParams({ channel: 'pos' });
      */
     updateOtherParams(params: Record<string, any>): void;
-    /**
-     * 判断当前商品查询是否会被本地 OS Server 接管。
-     *
-     * 不能只看请求参数中的 osServer=true：H5 RequestPlugin 会透传该参数，但仍然直接请求远端接口。
-     * 这里按 RequestPlugin 实际使用的 baseUrl 检查已注册路由，避免 OS Server 与客户端重复执行
-     * Data Variant 评估。
-     */
-    private isProductQueryHandledByOsServer;
-    /**
-     * 未启用商品 OS 路由时，在客户端补做 Data Variant 解析。
-     * OS Server 已接管时直接信任服务端结果，确保同一批商品只评估一次。
-     */
-    private resolveClientDataVariants;
     storeChange(path?: string, value?: any): Promise<void>;
     /**
      * 获取加时商品列表。
@@ -49,6 +37,19 @@ export declare class ProductList extends BaseModule implements Module {
         schedule_date?: string;
         channel?: string;
     }): Promise<any>;
+    /**
+     * Remember raw remote product records before client-side Data Variant
+     * evaluation. Quote-only reads can then always start from a clean baseline.
+     */
+    rememberRawProductQueryResult(products: Array<ProductData | Record<string, any>>): void;
+    private replaceRawProductQueryResult;
+    /**
+     * Return isolated raw price sources for the requested products.
+     *
+     * Missing IDs are intentionally omitted so callers can remotely fetch only
+     * the incomplete part of a batch quote.
+     */
+    getRawProductPriceSources(ids: number[]): Map<number, ProductData>;
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<ProductData | undefined>;
     getProductByIds(ids: number[]): Promise<ProductData[] | undefined>;

package/lib/modules/ProductList/index.js

@@ -10,6 +10,8 @@ exports.ProductList = void 0;
 var _BaseModule = require("../BaseModule");
 var _lodashEs = require("lodash-es");
 var _dayjs = _interopRequireDefault(require("dayjs"));
+var _clientDataVariants = require("./clientDataVariants");
+var _platform = require("../../utils/platform");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -29,6 +31,7 @@ class ProductList extends _BaseModule.BaseModule {
   store;
   request;
   otherParams = {};
+  rawProductPriceSources = new Map();
   constructor(name, version) {
     super(name, version);
   }
@@ -36,6 +39,7 @@ class ProductList extends _BaseModule.BaseModule {
     this.core = core;
     this.store = options.store;
     this.otherParams = options.otherParams || {};
+    this.rawProductPriceSources.clear();
     if (Array.isArray(options.initialState?.list)) {
       this.store.list = options.initialState.list.slice().sort((a, b) => Number(b.sort) - Number(a.sort));
       this.core.effects.emit(`${this.name}:changed`, this.store.list);
@@ -55,58 +59,6 @@ class ProductList extends _BaseModule.BaseModule {
   updateOtherParams(params) {
     this.otherParams = params || {};
   }
-
-  /**
-   * 判断当前商品查询是否会被本地 OS Server 接管。
-   *
-   * 不能只看请求参数中的 osServer=true：H5 RequestPlugin 会透传该参数，但仍然直接请求远端接口。
-   * 这里按 RequestPlugin 实际使用的 baseUrl 检查已注册路由，避免 OS Server 与客户端重复执行
-   * Data Variant 评估。
-   */
-  isProductQueryHandledByOsServer() {
-    const server = this.core?.server;
-    if (!server || typeof server.hasRoute !== 'function') return false;
-    const requestBaseUrl = String(this.request?.baseUrl || '/shop').replace(/\/+$/, '');
-    const routePath = `${requestBaseUrl}/product/query`;
-    return server.hasRoute('post', routePath) === true;
-  }
-
-  /**
-   * 未启用商品 OS 路由时，在客户端补做 Data Variant 解析。
-   * OS Server 已接管时直接信任服务端结果，确保同一批商品只评估一次。
-   */
-  resolveClientDataVariants(products, queryPayload, handledByOsServer) {
-    if (handledByOsServer || products.length === 0) return products;
-    const evaluator = this.core?.context?.dataVariantEvaluator;
-    if (!evaluator || typeof evaluator.resolveProducts !== 'function') {
-      return products;
-    }
-    const strategyContext = queryPayload.strategy_context && typeof queryPayload.strategy_context === 'object' ? queryPayload.strategy_context : {};
-    const fatherModule = String(this.otherParams?.fatherModule || '').trim();
-    const scheduleModule = (fatherModule ? this.core.getModule(`${fatherModule}_schedule`) : null) || this.core.getModule('schedule');
-    const scheduleList = scheduleModule?.getScheduleList?.();
-    const contextScheduleList = this.core?.context?.scheduleList;
-    const contextMenuList = this.core?.context?.menuList;
-    const businessData = {
-      products,
-      scheduleDateTime: queryPayload.schedule_datetime || queryPayload.schedule_date,
-      scheduleList: Array.isArray(scheduleList) ? scheduleList : Array.isArray(contextScheduleList) ? contextScheduleList : [],
-      menuList: Array.isArray(this.otherParams?.menuList) ? this.otherParams.menuList : Array.isArray(contextMenuList) ? contextMenuList : [],
-      customerId: queryPayload.customer_id,
-      channel: strategyContext.channel,
-      orderType: strategyContext.orderType || strategyContext.order_type,
-      businessCode: strategyContext.business_code ?? strategyContext.businessCode,
-      availableWalletIds: strategyContext.available_wallet_ids,
-      custom: strategyContext
-    };
-    try {
-      const result = evaluator.resolveProducts(businessData);
-      return Array.isArray(result?.products) ? result.products : products;
-    } catch (error) {
-      console.error('[ProductList] Data Variant 客户端解析失败', error);
-      return products;
-    }
-  }
   async storeChange(path, value) {
     // No longer needed - products are stored as plain objects instead of Product instances
   }
@@ -170,10 +122,12 @@ class ProductList extends _BaseModule.BaseModule {
     const rawApplicationCode = this.otherParams?.channel;
     const mappedApplicationCode = typeof rawApplicationCode === 'string' ? channelMap[rawApplicationCode] || rawApplicationCode : rawApplicationCode;
     const queryPayload = {
-      open_quotation: 1,
+      ...((0, _platform.isCustomerUserPlatform)(this.otherParams?.platform) ? {} : {
+        open_quotation: 1
+      }),
       open_bundle: 0,
       exclude_extension_type: ['product_party', 'product_event', 'product_series_event', 'product_package_ticket', 'ticket', 'event_item'],
-      with: ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem', 'dataVariants'],
+      with: [..._clientDataVariants.PRODUCT_QUERY_DATA_VARIANT_RELATIONS],
       status,
       num: 500,
       skip: 1,
@@ -201,7 +155,7 @@ class ProductList extends _BaseModule.BaseModule {
       extension_type,
       strategy_context
     };
-    const handledByOsServer = this.isProductQueryHandledByOsServer();
+    const handledByOsServer = (0, _clientDataVariants.isProductQueryHandledByOsServer)(this.core, this.request);
     const originalCallback = options?.callback;
     const subscriptionCallback = typeof originalCallback === 'function' ? async result => {
       const callbackList = result?.data?.list;
@@ -209,7 +163,18 @@ class ProductList extends _BaseModule.BaseModule {
         originalCallback(result);
         return;
       }
-      const products = this.resolveClientDataVariants(callbackList, queryPayload, handledByOsServer);
+      if (!handledByOsServer) {
+        // Subscription callbacks may contain only changed products. Upsert
+        // their raw records without evicting other IDs from the scope.
+        this.rememberRawProductQueryResult(callbackList);
+      }
+      const products = (0, _clientDataVariants.resolveClientDataVariants)({
+        core: this.core,
+        otherParams: this.otherParams,
+        products: callbackList,
+        queryPayload,
+        handledByOsServer
+      });
       await this.addProduct(products);
       originalCallback(handledByOsServer ? result : {
         ...result,
@@ -225,7 +190,16 @@ class ProductList extends _BaseModule.BaseModule {
       subscriberId: options?.subscriberId,
       customToast: () => {}
     });
-    const resolvedList = this.resolveClientDataVariants(productsData.data.list || [], queryPayload, handledByOsServer);
+    if (!handledByOsServer && Array.isArray(productsData.data.list)) {
+      this.replaceRawProductQueryResult(productsData.data.list, product_ids);
+    }
+    const resolvedList = (0, _clientDataVariants.resolveClientDataVariants)({
+      core: this.core,
+      otherParams: this.otherParams,
+      products: productsData.data.list || [],
+      queryPayload,
+      handledByOsServer
+    });
     const sortedList = resolvedList.slice().sort((a, b) => Number(b.sort) - Number(a.sort));
     // if (sortedList.length) {
     //   sortedList.forEach((n: any) => {
@@ -253,6 +227,51 @@ class ProductList extends _BaseModule.BaseModule {
     });
     return productsData.data;
   }
+
+  /**
+   * Remember raw remote product records before client-side Data Variant
+   * evaluation. Quote-only reads can then always start from a clean baseline.
+   */
+  rememberRawProductQueryResult(products) {
+    if (!Array.isArray(products)) return;
+    products.forEach(product => {
+      const source = product;
+      const id = Number(source?.id ?? source?.product_id);
+      if (!Number.isFinite(id)) return;
+      this.rawProductPriceSources.set(id, (0, _lodashEs.cloneDeep)(product));
+    });
+  }
+  replaceRawProductQueryResult(products, requestedIds) {
+    if (Array.isArray(requestedIds) && requestedIds.length > 0) {
+      requestedIds.forEach(rawId => {
+        const id = Number(rawId);
+        if (Number.isFinite(id)) this.rawProductPriceSources.delete(id);
+      });
+    } else {
+      // A non-ID query represents the latest catalog scope. Clearing before
+      // replacing prevents removed products from surviving indefinitely.
+      this.rawProductPriceSources.clear();
+    }
+    this.rememberRawProductQueryResult(products);
+  }
+
+  /**
+   * Return isolated raw price sources for the requested products.
+   *
+   * Missing IDs are intentionally omitted so callers can remotely fetch only
+   * the incomplete part of a batch quote.
+   */
+  getRawProductPriceSources(ids) {
+    const products = new Map();
+    if (!Array.isArray(ids)) return products;
+    ids.forEach(rawId => {
+      const id = Number(rawId);
+      if (!Number.isFinite(id) || products.has(id)) return;
+      const product = this.rawProductPriceSources.get(id);
+      if (product) products.set(id, (0, _lodashEs.cloneDeep)(product));
+    });
+    return products;
+  }
   async getProducts() {
     await this.core.effects.emit(`${this.name}:onGetProducts`, this.store.list);
     return (0, _lodashEs.cloneDeep)(this.store.list);

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;