@pisell/pisellos 2.3.30 → 2.3.32

package/dist/model/strategy/adapter/dataVariant/adapter.d.ts

@@ -0,0 +1,50 @@
+import type { EvaluationResult, RuntimeContext } from '../../type';
+import type { BusinessAdapter } from '../type';
+import type { DataVariantBusinessData, DataVariantProduct } from './type';
+/**
+ * Data Variant 适配器。
+ *
+ * 负责把智能定价运行态数据转换为 StrategyEngine 能识别的 attributes。
+ */
+export declare class DataVariantAdapter implements BusinessAdapter {
+    name: string;
+    version: string;
+    /**
+     * 准备批量全局上下文。
+     *
+     * 这里只放不依赖单个商品的字段，用于预计算 schedule/channel/orderType 等条件。
+     */
+    prepareContext(businessData: DataVariantBusinessData): RuntimeContext;
+    /**
+     * 准备全局预计算上下文。
+     */
+    prepareGlobalContext(businessData: DataVariantBusinessData): RuntimeContext;
+    /**
+     * 准备单商品上下文。
+     *
+     * 商品级条件只在当前商品 data_variants 引用到对应规则后才评估。
+     */
+    prepareProductContext(businessData: DataVariantBusinessData, product: DataVariantProduct): RuntimeContext;
+    transformResult(result: EvaluationResult): EvaluationResult;
+    formatConfig(result: EvaluationResult, businessData?: DataVariantBusinessData): {
+        result: EvaluationResult;
+        businessData?: DataVariantBusinessData;
+    };
+    /**
+     * 构建 menu_match 使用的轻量商品对象。
+     *
+     * collection_ids 来自商品 collection 字段，避免 operator 读取复杂商品对象。
+     */
+    buildProductValue(product: DataVariantProduct): {
+        id: number;
+        product_variant_id: number;
+        collection_ids: number[];
+    };
+    private toNumber;
+    /**
+     * 归一化客户 id：无效值返回 undefined，有效值统一为 number。
+     */
+    private normalizeCustomerId;
+    private normalizeNumberArray;
+}
+export default DataVariantAdapter;

package/dist/model/strategy/adapter/dataVariant/adapter.js

@@ -0,0 +1,167 @@
+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); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Data Variant 适配器。
+ *
+ * 负责把智能定价运行态数据转换为 StrategyEngine 能识别的 attributes。
+ */
+export var DataVariantAdapter = /*#__PURE__*/function () {
+  function DataVariantAdapter() {
+    _classCallCheck(this, DataVariantAdapter);
+    _defineProperty(this, "name", 'DataVariantAdapter');
+    _defineProperty(this, "version", '1.0.0');
+  }
+  _createClass(DataVariantAdapter, [{
+    key: "prepareContext",
+    value:
+    /**
+     * 准备批量全局上下文。
+     *
+     * 这里只放不依赖单个商品的字段，用于预计算 schedule/channel/orderType 等条件。
+     */
+    function prepareContext(businessData) {
+      return this.prepareGlobalContext(businessData);
+    }
+
+    /**
+     * 准备全局预计算上下文。
+     */
+  }, {
+    key: "prepareGlobalContext",
+    value: function prepareGlobalContext(businessData) {
+      var products = businessData.products,
+        scheduleDateTime = businessData.scheduleDateTime,
+        channel = businessData.channel,
+        orderType = businessData.orderType,
+        businessCode = businessData.businessCode,
+        customerId = businessData.customerId,
+        availableWalletIds = businessData.availableWalletIds,
+        custom = businessData.custom;
+
+      // customer_id 统一归一化为 number，避免 in 运算符因 string/number 不一致而误判
+      var normalizedCustomerId = this.normalizeCustomerId(customerId);
+      var normalizedAvailableWalletIds = this.normalizeNumberArray(availableWalletIds !== null && availableWalletIds !== void 0 ? availableWalletIds : custom === null || custom === void 0 ? void 0 : custom.available_wallet_ids);
+      var resolvedBusinessCode = businessCode || (custom === null || custom === void 0 ? void 0 : custom.business_code) || (custom === null || custom === void 0 ? void 0 : custom.businessCode) || '';
+      return {
+        entities: {
+          products: products
+        },
+        attributes: _objectSpread(_objectSpread({}, custom), {}, {
+          schedule: scheduleDateTime || '',
+          channel: channel || (custom === null || custom === void 0 ? void 0 : custom.channel) || '',
+          orderType: orderType || (custom === null || custom === void 0 ? void 0 : custom.orderType) || (custom === null || custom === void 0 ? void 0 : custom.order_type) || '',
+          // snake_case 与策略配置 field 对齐；customerId 保留兼容旧配置
+          customer_id: normalizedCustomerId,
+          customerId: normalizedCustomerId,
+          available_wallet_ids: normalizedAvailableWalletIds,
+          availableWalletIds: normalizedAvailableWalletIds,
+          business_code: resolvedBusinessCode
+        }),
+        metadata: {
+          timestamp: Date.now()
+        }
+      };
+    }
+
+    /**
+     * 准备单商品上下文。
+     *
+     * 商品级条件只在当前商品 data_variants 引用到对应规则后才评估。
+     */
+  }, {
+    key: "prepareProductContext",
+    value: function prepareProductContext(businessData, product) {
+      var base = this.prepareGlobalContext(businessData);
+      var productValue = this.buildProductValue(product);
+      return _objectSpread(_objectSpread({}, base), {}, {
+        entities: _objectSpread(_objectSpread({}, base.entities), {}, {
+          currentProduct: product
+        }),
+        attributes: _objectSpread(_objectSpread({}, base.attributes), {}, {
+          product: productValue,
+          productIdAndVariantId: {
+            product_id: productValue.id,
+            product_variant_id: productValue.product_variant_id
+          }
+        })
+      });
+    }
+  }, {
+    key: "transformResult",
+    value: function transformResult(result) {
+      return result;
+    }
+  }, {
+    key: "formatConfig",
+    value: function formatConfig(result, businessData) {
+      return {
+        result: result,
+        businessData: businessData
+      };
+    }
+
+    /**
+     * 构建 menu_match 使用的轻量商品对象。
+     *
+     * collection_ids 来自商品 collection 字段，避免 operator 读取复杂商品对象。
+     */
+  }, {
+    key: "buildProductValue",
+    value: function buildProductValue(product) {
+      var _product$id,
+        _product$product_vari,
+        _this = this;
+      var productId = this.toNumber((_product$id = product.id) !== null && _product$id !== void 0 ? _product$id : product.product_id);
+      var variantId = this.toNumber((_product$product_vari = product.product_variant_id) !== null && _product$product_vari !== void 0 ? _product$product_vari : product.variant_id);
+      var collectionIds = Array.isArray(product.collection) ? product.collection.map(function (item) {
+        return _this.toNumber(item === null || item === void 0 ? void 0 : item.id);
+      }).filter(function (id) {
+        return id > 0;
+      }) : [];
+      return {
+        id: productId,
+        product_variant_id: variantId,
+        collection_ids: collectionIds
+      };
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber(value) {
+      var parsed = Number(value);
+      return Number.isFinite(parsed) ? parsed : 0;
+    }
+
+    /**
+     * 归一化客户 id：无效值返回 undefined，有效值统一为 number。
+     */
+  }, {
+    key: "normalizeCustomerId",
+    value: function normalizeCustomerId(value) {
+      if (value === undefined || value === null || value === '') {
+        return undefined;
+      }
+      var parsed = Number(value);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+  }, {
+    key: "normalizeNumberArray",
+    value: function normalizeNumberArray(value) {
+      if (!Array.isArray(value)) return [];
+      var ids = value.map(function (item) {
+        return Number(item);
+      }).filter(function (item) {
+        return Number.isFinite(item) && item > 0;
+      });
+      return Array.from(new Set(ids));
+    }
+  }]);
+  return DataVariantAdapter;
+}();
+export default DataVariantAdapter;

package/dist/model/strategy/adapter/dataVariant/evaluator.d.ts

@@ -0,0 +1,89 @@
+import type { ConditionRule, StrategyConfig } from '../../type';
+import type { ConditionScope, DataVariantBusinessData, DataVariantMenu, DataVariantRuleMetadata, MenuScope, ResolvedDataVariantResult } from './type';
+/**
+ * Data Variant 评估器。
+ *
+ * 当前阶段只提供策略模型能力和示例验证，不接入 ProductList 业务链路。
+ */
+export declare class DataVariantEvaluator {
+    private adapter;
+    private strategyConfigs;
+    constructor();
+    /**
+     * 设置策略配置列表，仅保留 metadata.type === 'data_variant' 的策略。
+     */
+    setStrategyConfigs(configs: StrategyConfig[]): void;
+    getStrategyConfigs(): StrategyConfig<DataVariantRuleMetadata>[];
+    /**
+     * 批量解析商品 Data Variant。
+     *
+     * 先执行全局预计算，再只针对商品自身 data_variants 引用到的规则做商品级判断。
+     */
+    resolveProducts(businessData: DataVariantBusinessData): ResolvedDataVariantResult;
+    /**
+     * 根据 operator/field 判断条件是否依赖当前商品。
+     */
+    getConditionScope(rule: ConditionRule): ConditionScope;
+    /**
+     * 将餐牌 partyroom_package 预构建为 Map/Set 索引。
+     */
+    buildMenuScopeMap(menuList: DataVariantMenu[]): Map<number, MenuScope>;
+    /**
+     * 从当前策略中所有 schedule_match.value 绑定的 schedule_id 提取时间点。
+     *
+     * 这里不依赖餐牌，只读取策略配置和调用方传入的 scheduleList。
+     */
+    buildScheduleTimePoints(strategyConfigs: StrategyConfig<DataVariantRuleMetadata>[], scheduleList: NonNullable<DataVariantBusinessData['scheduleList']>): string[];
+    private buildGlobalEffectiveRuleMap;
+    private resolveProduct;
+    /**
+     * 解析套餐子商品上的 Data Variant 覆盖。
+     *
+     * bundle_item 以 bundle_product_id / bundle_variant_id 作为商品身份参与 product_match 等条件判断。
+     */
+    private resolveProductBundleItems;
+    /**
+     * 将 bundle_item 转为 DataVariantProduct 并评估 data_variants。
+     */
+    private resolveBundleItem;
+    /**
+     * bundle_item 的商品身份映射：bundle_product_id + bundle_variant_id。
+     */
+    private toBundleItemDataVariantProduct;
+    /**
+     * 仅回写命中的字段，避免污染 bundle_item 的结构字段。
+     */
+    private mergeBundleItemResolvedData;
+    private evaluateProductRules;
+    /**
+     * 拆分策略条件。
+     *
+     * 当前 MVP 支持顶层 and 原子条件拆分；复杂条件保守地放到商品级完整判断。
+     */
+    private splitStrategyConfig;
+    private createEngine;
+    private evaluateScheduleMatch;
+    private evaluateMenuMatch;
+    private evaluateArrayIntersects;
+    private collectScheduleIdsFromStrategies;
+    private extractTimePointsFromSchedules;
+    private addDateTimePoint;
+    private addRawTimePoint;
+    private extractTimeFromDateTime;
+    private normalizeTime;
+    private timeToMinutes;
+    private isProductInMenuScope;
+    private mergeMatchedVariants;
+    private getProductDataVariants;
+    private normalizeStrategyConfigs;
+    private isStrategyActive;
+    private getStrategyPriority;
+    private createAlwaysTrueConditions;
+    private flattenConditionRules;
+    private isConditionGroup;
+    private normalizeNumberArray;
+    private normalizeComparableArray;
+    private buildProductKey;
+    private toNumber;
+}
+export default DataVariantEvaluator;