@pisell/pisellos 0.10.21 → 0.10.23

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,15 +155,26 @@ class ProductList extends _BaseModule.BaseModule {
       extension_type,
       strategy_context
     };
-    const handledByOsServer = this.isProductQueryHandledByOsServer();
-    const originalCallback = options?.callback;
+    const handledByOsServer = (0, _clientDataVariants.isProductQueryHandledByOsServer)(this.core, this.request);
+    const originalCallback = typeof options?.callback === 'function' ? options.callback : undefined;
     const subscriptionCallback = originalCallback ? async result => {
       const callbackList = result?.data?.list;
       if (!Array.isArray(callbackList)) {
         originalCallback(result);
         return;
       }
-      const resolvedCallbackList = this.resolveClientDataVariants(callbackList, queryPayload, handledByOsServer);
+      if (!handledByOsServer) {
+        // Subscription payloads may contain only changed products, so keep
+        // the existing raw catalog scope and upsert the changed records.
+        this.rememberRawProductQueryResult(callbackList);
+      }
+      const resolvedCallbackList = (0, _clientDataVariants.resolveClientDataVariants)({
+        core: this.core,
+        otherParams: this.otherParams,
+        products: callbackList,
+        queryPayload,
+        handledByOsServer
+      });
       await this.addProduct(resolvedCallbackList);
       originalCallback(resolvedCallbackList === callbackList ? 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/modules/Quotation/index.d.ts

@@ -9,12 +9,23 @@ export declare class QuotationModule extends BaseModule implements Module {
     private request;
     private store;
     private scheduleResolver?;
+    private quotationCache;
+    private quotationLoadPromises;
+    private quotationCacheVersions;
+    private lifecycleGeneration;
+    private activeChannelKey;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     loadQuotations(params?: {
         channel?: string;
         customer_id?: number | string;
     }): Promise<void>;
+    ensureQuotations(params?: {
+        channel?: string;
+        customer_id?: number | string;
+    }): Promise<void>;
+    invalidateQuotationCache(channel?: string): void;
+    private fetchQuotations;
     getQuotationList(): QuotationItem[];
     getQuotationCustomerScopeInfo(): QuotationCustomerScopeInfo;
     /**
@@ -57,9 +68,14 @@ export declare class QuotationModule extends BaseModule implements Module {
     buildProductPriceMap(params: {
         productIds: number[];
         timePoints: string[];
+        channel?: string;
         customer_id?: number | string;
     }): Map<string, string | null>;
     setScheduleResolver(resolver: (id: number) => ScheduleItem | undefined): void;
+    private normalizeChannel;
+    private activateChannel;
+    private getQuotationCacheVersion;
+    private bumpQuotationCacheVersion;
     private isQuotationVisibleForCustomer;
     private hasValidCustomerId;
     private normalizeCustomerId;

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;