@pisell/pisellos 2.2.291 → 2.2.293

package/dist/modules/ProductList/clientDataVariants.js

@@ -0,0 +1,216 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+export var PRODUCT_QUERY_DATA_VARIANT_RELATIONS = ['category', 'collection', 'resourceRelation', 'bundleGroup.bundleItem', 'optionGroup.optionItem', 'variantGroup.variantItem', 'dataVariants'];
+
+/**
+ * 判断当前商品查询是否会被本地 OS Server 接管。
+ *
+ * H5 RequestPlugin 即使收到 osServer=true 仍会直接请求远端接口，因此必须按
+ * RequestPlugin 实际 baseUrl 对应的已注册路由判断，不能只看请求选项。
+ */
+export function isProductQueryHandledByOsServer(core, request) {
+  var server = core === null || core === void 0 ? void 0 : core.server;
+  if (!server || typeof server.hasRoute !== 'function') return false;
+  var requestBaseUrl = String((request === null || request === void 0 ? void 0 : request.baseUrl) || '/shop').replace(/\/+$/, '');
+  return server.hasRoute('post', "".concat(requestBaseUrl, "/product/query")) === true;
+}
+function getBundleItems(product) {
+  if (!Array.isArray(product.bundle_group)) return [];
+  return product.bundle_group.flatMap(function (group) {
+    return Array.isArray(group === null || group === void 0 ? void 0 : group.bundle_item) ? group.bundle_item : [];
+  });
+}
+function hasCompleteDataVariantRelations(products) {
+  return products.every(function (product) {
+    return Array.isArray(product === null || product === void 0 ? void 0 : product.data_variants);
+  });
+}
+function hasAnyDataVariants(products) {
+  return products.some(function (product) {
+    var _product$data_variant;
+    return (((_product$data_variant = product.data_variants) === null || _product$data_variant === void 0 ? void 0 : _product$data_variant.length) || 0) > 0 || getBundleItems(product).some(function (item) {
+      return Array.isArray(item === null || item === void 0 ? void 0 : item.data_variants) && item.data_variants.length > 0;
+    });
+  });
+}
+function collectReferencedRuleIds(products) {
+  var ids = new Set();
+  var remember = function remember(variants) {
+    if (!Array.isArray(variants)) return;
+    variants.forEach(function (variant) {
+      var _variant$data_variant;
+      var id = String((_variant$data_variant = variant === null || variant === void 0 ? void 0 : variant.data_variant_rule_id) !== null && _variant$data_variant !== void 0 ? _variant$data_variant : '').trim();
+      if (id) ids.add(id);
+    });
+  };
+  products.forEach(function (product) {
+    remember(product.data_variants);
+    getBundleItems(product).forEach(function (item) {
+      return remember(item === null || item === void 0 ? void 0 : 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') {
+    var configs = evaluator.getStrategyConfigs();
+    if (!Array.isArray(configs) || configs.length === 0) return false;
+    var availableRuleIds = new Set(configs.map(function (config) {
+      var _config$metadata$id, _config$metadata;
+      return String((_config$metadata$id = config === null || config === void 0 || (_config$metadata = config.metadata) === null || _config$metadata === void 0 ? void 0 : _config$metadata.id) !== null && _config$metadata$id !== void 0 ? _config$metadata$id : '').trim();
+    }).filter(Boolean));
+    return Array.from(collectReferencedRuleIds(products)).every(function (id) {
+      return 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.
+ */
+export function tryResolveClientDataVariants(_ref) {
+  var _core$context, _scheduleModule$getSc, _core$context2, _core$context3, _strategyContext$busi;
+  var core = _ref.core,
+    _ref$otherParams = _ref.otherParams,
+    otherParams = _ref$otherParams === void 0 ? {} : _ref$otherParams,
+    products = _ref.products,
+    queryPayload = _ref.queryPayload,
+    handledByOsServer = _ref.handledByOsServer,
+    explicitScheduleList = _ref.scheduleList,
+    explicitMenuList = _ref.menuList,
+    _ref$requireCompleteD = _ref.requireCompleteDataVariantRelations,
+    requireCompleteDataVariantRelations = _ref$requireCompleteD === void 0 ? true : _ref$requireCompleteD,
+    _ref$requireEvaluator = _ref.requireEvaluatorReady,
+    requireEvaluatorReady = _ref$requireEvaluator === void 0 ? true : _ref$requireEvaluator;
+  if (handledByOsServer) {
+    return {
+      status: 'handled-by-os-server',
+      products: products
+    };
+  }
+  if (products.length === 0) {
+    return {
+      status: 'empty',
+      products: products
+    };
+  }
+  if (requireCompleteDataVariantRelations && !hasCompleteDataVariantRelations(products)) {
+    return {
+      status: 'data-variants-unavailable',
+      products: 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: products
+    };
+  }
+  var evaluator = core === null || core === void 0 || (_core$context = core.context) === null || _core$context === void 0 ? void 0 : _core$context.dataVariantEvaluator;
+  if (!evaluator || typeof evaluator.resolveProducts !== 'function') {
+    return {
+      status: 'evaluator-unavailable',
+      products: products
+    };
+  }
+  try {
+    if (requireEvaluatorReady && !isEvaluatorReady(evaluator, products)) {
+      return {
+        status: 'evaluator-not-ready',
+        products: products
+      };
+    }
+  } catch (error) {
+    return {
+      status: 'error',
+      products: products,
+      error: error
+    };
+  }
+  var strategyContext = queryPayload.strategy_context && _typeof(queryPayload.strategy_context) === 'object' ? queryPayload.strategy_context : {};
+  var fatherModule = String(otherParams.fatherModule || '').trim();
+  var scheduleModule = (fatherModule ? core === null || core === void 0 ? void 0 : core.getModule("".concat(fatherModule, "_schedule")) : null) || (core === null || core === void 0 ? void 0 : core.getModule('schedule'));
+  var moduleScheduleList = scheduleModule === null || scheduleModule === void 0 || (_scheduleModule$getSc = scheduleModule.getScheduleList) === null || _scheduleModule$getSc === void 0 ? void 0 : _scheduleModule$getSc.call(scheduleModule);
+  var contextScheduleList = core === null || core === void 0 || (_core$context2 = core.context) === null || _core$context2 === void 0 ? void 0 : _core$context2.scheduleList;
+  var contextMenuList = core === null || core === void 0 || (_core$context3 = core.context) === null || _core$context3 === void 0 ? void 0 : _core$context3.menuList;
+  var businessData = {
+    products: 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$busi = strategyContext.business_code) !== null && _strategyContext$busi !== void 0 ? _strategyContext$busi : strategyContext.businessCode,
+    availableWalletIds: strategyContext.available_wallet_ids,
+    custom: strategyContext
+  };
+  try {
+    var result = evaluator.resolveProducts(businessData);
+    if (!Array.isArray(result === null || result === void 0 ? void 0 : result.products)) {
+      return {
+        status: 'error',
+        products: products,
+        error: new Error('Data Variant evaluator returned an invalid product list')
+      };
+    }
+    return {
+      status: 'resolved',
+      products: result.products
+    };
+  } catch (error) {
+    return {
+      status: 'error',
+      products: products,
+      error: error
+    };
+  }
+}
+
+/**
+ * 未启用商品 OS 路由时，在客户端补做 Data Variant 解析。
+ *
+ * 商品列表和预约报价必须共用这个边界，避免 H5 的弹窗报价绕过客户端智能定价。
+ * OS Server 已接管时直接信任服务端结果，确保同一批商品只评估一次。
+ */
+export function resolveClientDataVariants(_ref2) {
+  var core = _ref2.core,
+    _ref2$otherParams = _ref2.otherParams,
+    otherParams = _ref2$otherParams === void 0 ? {} : _ref2$otherParams,
+    products = _ref2.products,
+    queryPayload = _ref2.queryPayload,
+    handledByOsServer = _ref2.handledByOsServer,
+    explicitScheduleList = _ref2.scheduleList,
+    explicitMenuList = _ref2.menuList;
+  var result = tryResolveClientDataVariants({
+    core: core,
+    otherParams: otherParams,
+    products: products,
+    queryPayload: queryPayload,
+    handledByOsServer: handledByOsServer,
+    scheduleList: explicitScheduleList,
+    menuList: explicitMenuList,
+    requireCompleteDataVariantRelations: false,
+    requireEvaluatorReady: false
+  });
+  if (result.status === 'error') {
+    console.error('[ClientDataVariants] Data Variant 客户端解析失败', result.error);
+  }
+  return result.products;
+}

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

@@ -1,6 +1,6 @@
 import { Module, PisellCore } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { ProductListLoadProductsParams } from './types';
+import { ProductListLoadProductsParams, ProductListStoreQueryParams } from './types';
 import { ProductData } from '../Product/types';
 export * from './types';
 export declare class ProductList extends BaseModule implements Module {
@@ -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>;
     /**
@@ -25,19 +26,33 @@ export declare class ProductList extends BaseModule implements Module {
      * @example
      * const products = await productList.getAddTimeProducts({ schedule_date: '2026-06-16' });
      */
-    getAddTimeProducts(params?: ProductListLoadProductsParams): Promise<any>;
+    getAddTimeProducts(params?: ProductListLoadProductsParams): Promise<ProductData[]>;
     loadProducts({ category_ids, product_ids, collection, menu_list_ids, customer_id: paramsCustomerId, with_count, schedule_datetime, schedule_date, cacheId, with_schedule, extension_type, status, strategy_context, }?: ProductListLoadProductsParams, options?: {
         callback?: (result: any) => void;
         subscriberId?: string;
-    }): Promise<any>;
+    }): Promise<ProductData[]>;
     loadProductsPrice({ ids, customer_id, schedule_date, channel, }: {
         ids?: number[];
         customer_id?: number;
         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>;
+    queryProducts(params?: ProductListStoreQueryParams): Promise<ProductData[]>;
     getProductByIds(ids: number[]): Promise<ProductData[] | undefined>;
     addProduct(products: ProductData[]): Promise<void>;
     selectProducts(products: ProductData[]): Promise<void>;