@pisell/pisellos 2.1.118 → 2.1.120

package/dist/model/strategy/adapter/itemRule/evaluator.js

@@ -0,0 +1,169 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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); }
+import { StrategyEngine } from "../../engine";
+import { ItemRuleAdapter } from "./adapter";
+import { ITEM_RULE_ACTION_TYPES } from "./type";
+
+/**
+ * ItemRule 评估器
+ *
+ * 组合 StrategyEngine + ItemRuleAdapter，提供面向业务的高层 API。
+ * 支持批量评估多条 item_rule 策略配置，聚合数量校验和预填购物车结果。
+ */
+export var ItemRuleEvaluator = /*#__PURE__*/function () {
+  function ItemRuleEvaluator() {
+    _classCallCheck(this, ItemRuleEvaluator);
+    _defineProperty(this, "engine", void 0);
+    _defineProperty(this, "adapter", void 0);
+    _defineProperty(this, "strategyConfigs", []);
+    this.engine = new StrategyEngine({
+      debug: false,
+      enableTrace: false
+    });
+    this.adapter = new ItemRuleAdapter();
+  }
+
+  /**
+   * 设置策略配置列表
+   * 自动过滤 metadata.type === 'item_rule' 的配置
+   */
+  _createClass(ItemRuleEvaluator, [{
+    key: "setStrategyConfigs",
+    value: function setStrategyConfigs(configs) {
+      this.strategyConfigs = configs.filter(function (c) {
+        return c.metadata.type === 'item_rule';
+      });
+    }
+  }, {
+    key: "getStrategyConfigs",
+    value: function getStrategyConfigs() {
+      return this.strategyConfigs;
+    }
+
+    /**
+     * 完整评估：数量校验 + 预填购物车
+     */
+  }, {
+    key: "evaluate",
+    value: function evaluate(businessData) {
+      var configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter(function (c) {
+        return c.metadata.type === 'item_rule';
+      }) : this.strategyConfigs;
+      var allQuantityChecks = [];
+      var allPrefillItems = [];
+      var rawResults = [];
+      var context = this.adapter.prepareContext(businessData);
+      var _iterator = _createForOfIteratorHelper(configs),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var config = _step.value;
+          var evalResult = this.engine.evaluate(config, context);
+          rawResults.push(evalResult);
+          var _this$adapter$transfo = this.adapter.transformResult(evalResult, businessData),
+            quantityChecks = _this$adapter$transfo.quantityChecks,
+            prefillItems = _this$adapter$transfo.prefillItems;
+          allQuantityChecks.push.apply(allQuantityChecks, _toConsumableArray(quantityChecks));
+          allPrefillItems.push.apply(allPrefillItems, _toConsumableArray(prefillItems));
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var failedChecks = allQuantityChecks.filter(function (c) {
+        return !c.passed;
+      });
+      return {
+        quantityChecks: allQuantityChecks,
+        prefillItems: allPrefillItems,
+        allPassed: failedChecks.length === 0,
+        failedChecks: failedChecks,
+        rawResults: rawResults
+      };
+    }
+
+    /**
+     * 获取当前配置中各商品的数量限制
+     *
+     * 不做购物车校验，仅从策略配置中提取 QUANTITY_CHECK 规则的
+     * min / max / exact / mustInclude 限制值。
+     * 会评估条件是否满足、根据 scope + submissionIndex 过滤。
+     */
+  }, {
+    key: "getQuantityLimits",
+    value: function getQuantityLimits(businessData) {
+      var configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter(function (c) {
+        return c.metadata.type === 'item_rule';
+      }) : this.strategyConfigs;
+      var results = [];
+      var context = this.adapter.prepareContext(businessData);
+      var _iterator2 = _createForOfIteratorHelper(configs),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var config = _step2.value;
+          var evalResult = this.engine.evaluate(config, context);
+          if (!evalResult.applicable) continue;
+          var _iterator3 = _createForOfIteratorHelper(evalResult.matchedActions),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var action = _step3.value;
+              if (action.type !== ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK) continue;
+              var limit = this.adapter.extractQuantityLimits(action, businessData);
+              if (limit) {
+                results.push(limit);
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return results;
+    }
+
+    /**
+     * 便捷方法：仅做数量校验，返回是否全部通过及失败详情
+     */
+  }, {
+    key: "validateCart",
+    value: function validateCart(businessData) {
+      var result = this.evaluate(businessData);
+      return {
+        passed: result.allPassed,
+        failures: result.failedChecks
+      };
+    }
+
+    /**
+     * 便捷方法：仅获取需要预填到购物车的商品
+     */
+  }, {
+    key: "getPrefillItems",
+    value: function getPrefillItems(businessData) {
+      var result = this.evaluate(businessData);
+      return result.prefillItems;
+    }
+  }]);
+  return ItemRuleEvaluator;
+}();

package/dist/model/strategy/adapter/itemRule/examples.d.ts

@@ -0,0 +1,64 @@
+import type { StrategyConfig } from '../../type';
+/**
+ * 场景：火锅店扫码点餐，要求小料数量 >= 成人人数，自动添加到购物车
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 小料最少数量 = Adult Pax
+ *   - Prefill Cart: 自动添加小料 x Adult Pax
+ */
+export declare const MIN_CONDIMENT_PER_PERSON_STRATEGY: StrategyConfig;
+/**
+ * 场景：包子限量供应，每桌最多3份（含加单累计），肉包和菜包合计
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 肉包 + 菜包 合计 <= 3，scope=cumulative
+ */
+export declare const MAX_BUNS_PER_TABLE_STRATEGY: StrategyConfig;
+/**
+ * 场景：堂食必须选择一个锅底（按商品匹配），自动预填默认锅底
+ *
+ * WHEN: Service Type = Dine-in
+ * THEN:
+ *   - Quantity Check: 指定锅底商品精确1份
+ *   - Prefill Cart: 自动添加默认锅底 x 1
+ */
+export declare const HOTPOT_BASE_REQUIRED_STRATEGY: StrategyConfig;
+/**
+ * ItemRuleEvaluator 简洁调用示例
+ *
+ * 覆盖方法：
+ * - setStrategyConfigs
+ * - getStrategyConfigs
+ * - evaluate
+ * - getQuantityLimits
+ * - validateCart
+ * - getPrefillItems
+ */
+export declare function quickUseItemRuleEvaluator(): {
+    configCount: number;
+    evaluation: import("./type").ItemRuleEvaluationResult;
+    quantityLimits: import("./type").QuantityLimitResult[];
+    validation: {
+        passed: boolean;
+        failures: import("./type").QuantityCheckResult[];
+    };
+    prefillItems: import("./type").PrefillItemResult[];
+};
+/**
+ * ItemRuleEvaluator 完整可运行 Demo
+ *
+ * 说明：
+ * 1) 首次提交：触发 first_submission_only + cumulative + 条件规则
+ * 2) 追加提交：演示 first_submission_only 不再触发
+ * 3) 覆盖 strategyConfigs 临时传入：演示按需仅评估部分规则
+ */
+export declare function runItemRuleEvaluatorDemo(): {
+    firstEvaluation: import("./type").ItemRuleEvaluationResult;
+    validateResult: {
+        passed: boolean;
+        failures: import("./type").QuantityCheckResult[];
+    };
+    prefillItems: import("./type").PrefillItemResult[];
+};

package/dist/model/strategy/adapter/itemRule/examples.js

@@ -0,0 +1,315 @@
+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 _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); }
+import { ItemRuleEvaluator } from "./evaluator";
+import { ITEM_RULE_ACTION_TYPES } from "./type";
+// ============================================
+// 示例 1：每人至少一份小料 (Minimum Per Person)
+// ============================================
+
+/**
+ * 场景：火锅店扫码点餐，要求小料数量 >= 成人人数，自动添加到购物车
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 小料最少数量 = Adult Pax
+ *   - Prefill Cart: 自动添加小料 x Adult Pax
+ */
+export var MIN_CONDIMENT_PER_PERSON_STRATEGY = {
+  metadata: {
+    id: 'RULE_MIN_CONDIMENT_PER_PERSON',
+    name: {
+      'zh-CN': '每人至少一份小料',
+      en: 'Min 1 Condiment per person'
+    },
+    type: 'item_rule',
+    description: {
+      'zh-CN': '火锅小料数量不少于成人人数，自动添加',
+      en: 'Condiment count must be at least adult pax, auto-added to cart'
+    }
+  },
+  conditions: {
+    operator: 'and',
+    rules: [],
+    actionIds: ['quantity_check_condiment', 'prefill_condiment']
+  },
+  actions: [{
+    id: 'quantity_check_condiment',
+    type: ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK,
+    value: null,
+    target: 'cart',
+    priority: 10,
+    config: {
+      targetType: 'product',
+      targets: [{
+        product_id: 10001
+      }, {
+        product_id: 10002
+      }],
+      quantityRules: [{
+        comparison: 'minimum',
+        source: 'total_pax'
+      }],
+      scope: 'first_submission_only',
+      validationMessage: {
+        'zh-CN': '小料至少需要 {min} 份（每位成人一份）',
+        en: 'Condiment requires at least {min} items (one per adult)'
+      }
+    }
+  }, {
+    id: 'prefill_condiment',
+    type: ITEM_RULE_ACTION_TYPES.PREFILL_CART,
+    value: null,
+    target: 'cart',
+    priority: 5,
+    config: {
+      products: [{
+        product_id: 10001,
+        quantityFrom: 'total_pax'
+      }]
+    }
+  }]
+};
+
+// ============================================
+// 示例 2：每桌限量3份包子 (Maximum Per Table)
+// ============================================
+
+/**
+ * 场景：包子限量供应，每桌最多3份（含加单累计），肉包和菜包合计
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 肉包 + 菜包 合计 <= 3，scope=cumulative
+ */
+export var MAX_BUNS_PER_TABLE_STRATEGY = {
+  metadata: {
+    id: 'RULE_MAX_BUNS_PER_TABLE',
+    name: {
+      'zh-CN': '每桌限量供应3份包子',
+      en: '3 Buns limit per table'
+    },
+    type: 'item_rule',
+    description: {
+      'zh-CN': '肉包和菜包合计每桌不超过3份，含加单累计',
+      en: 'Max 3 buns per table (pork + veggie combined, cumulative)'
+    }
+  },
+  conditions: {
+    operator: 'and',
+    rules: [],
+    actionIds: ['quantity_check_buns']
+  },
+  actions: [{
+    id: 'quantity_check_buns',
+    type: ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK,
+    value: null,
+    target: 'cart',
+    priority: 10,
+    config: {
+      targetType: 'product',
+      targets: [{
+        product_id: 20001
+      }, {
+        product_id: 20002
+      }],
+      quantityRules: [{
+        comparison: 'maximum',
+        source: 'fixed',
+        value: 3
+      }],
+      scope: 'cumulative',
+      validationMessage: {
+        'zh-CN': '包子每桌限量 {max} 份（含加单累计）',
+        en: 'Buns are limited to {max} per table (cumulative)'
+      }
+    }
+  }]
+};
+
+// ============================================
+// 示例 3：锅底必选 (Must Include - Conditional)
+// ============================================
+
+/**
+ * 场景：堂食必须选择一个锅底（按商品匹配），自动预填默认锅底
+ *
+ * WHEN: Service Type = Dine-in
+ * THEN:
+ *   - Quantity Check: 指定锅底商品精确1份
+ *   - Prefill Cart: 自动添加默认锅底 x 1
+ */
+export var HOTPOT_BASE_REQUIRED_STRATEGY = {
+  metadata: {
+    id: 'RULE_HOTPOT_BASE_REQUIRED',
+    name: {
+      'zh-CN': '锅底必选',
+      en: 'Hotpot base required'
+    },
+    type: 'item_rule',
+    description: {
+      'zh-CN': '堂食必须选择一个锅底',
+      en: 'Hotpot base is mandatory for dine-in'
+    }
+  },
+  conditions: {
+    operator: 'and',
+    rules: [{
+      type: 'operator',
+      dimension: 'context',
+      field: 'serviceType',
+      operator: '=',
+      value: 'dine-in'
+    }],
+    actionIds: ['quantity_check_base', 'prefill_base']
+  },
+  actions: [{
+    id: 'quantity_check_base',
+    type: ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK,
+    value: null,
+    target: 'cart',
+    priority: 10,
+    config: {
+      targetType: 'product',
+      targets: [{
+        product_id: 30001
+      }],
+      quantityRules: [{
+        comparison: 'exact',
+        source: 'fixed',
+        value: 1
+      }],
+      scope: 'first_submission_only',
+      validationMessage: {
+        'zh-CN': '请选择 {exact} 个锅底',
+        en: 'Please select exactly {exact} hotpot base'
+      }
+    }
+  }, {
+    id: 'prefill_base',
+    type: ITEM_RULE_ACTION_TYPES.PREFILL_CART,
+    value: null,
+    target: 'cart',
+    priority: 5,
+    config: {
+      products: [{
+        product_id: 30001,
+        quantityFrom: 'fixed',
+        quantity: 1
+      }]
+    }
+  }]
+};
+
+// ============================================
+// 示例 4：ItemRuleEvaluator 用法（简洁调用 + 完整 Demo）
+// ============================================
+
+/**
+ * ItemRuleEvaluator 简洁调用示例
+ *
+ * 覆盖方法：
+ * - setStrategyConfigs
+ * - getStrategyConfigs
+ * - evaluate
+ * - getQuantityLimits
+ * - validateCart
+ * - getPrefillItems
+ */
+export function quickUseItemRuleEvaluator() {
+  var evaluator = new ItemRuleEvaluator();
+  evaluator.setStrategyConfigs([MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY]);
+  var businessData = {
+    pax: {
+      total: 3,
+      adult: 3,
+      child: 0
+    },
+    serviceType: 'dine-in',
+    cartItems: [{
+      product_id: 10001,
+      quantity: 1
+    }, {
+      product_id: 20001,
+      quantity: 2
+    }, {
+      product_id: 20002,
+      quantity: 1
+    }],
+    historicalItems: [{
+      product_id: 20001,
+      quantity: 1
+    }],
+    submissionIndex: 0
+  };
+  return {
+    configCount: evaluator.getStrategyConfigs().length,
+    evaluation: evaluator.evaluate(businessData),
+    quantityLimits: evaluator.getQuantityLimits(businessData),
+    validation: evaluator.validateCart(businessData),
+    prefillItems: evaluator.getPrefillItems(businessData)
+  };
+}
+
+/**
+ * ItemRuleEvaluator 完整可运行 Demo
+ *
+ * 说明：
+ * 1) 首次提交：触发 first_submission_only + cumulative + 条件规则
+ * 2) 追加提交：演示 first_submission_only 不再触发
+ * 3) 覆盖 strategyConfigs 临时传入：演示按需仅评估部分规则
+ */
+export function runItemRuleEvaluatorDemo() {
+  var evaluator = new ItemRuleEvaluator();
+  evaluator.setStrategyConfigs([MIN_CONDIMENT_PER_PERSON_STRATEGY
+  // MAX_BUNS_PER_TABLE_STRATEGY,
+  // HOTPOT_BASE_REQUIRED_STRATEGY,
+  ]);
+  var firstSubmissionData = {
+    pax: {
+      total: 4,
+      adult: 3,
+      child: 1
+    },
+    serviceType: 'dine-in',
+    submissionIndex: 0,
+    cartItems: [{
+      product_id: 10001,
+      quantity: 3
+    }
+    // { product_id: 20001, quantity: 2 },
+    // { product_id: 20002, quantity: 1 },
+    ],
+    historicalItems: [{
+      product_id: 20001,
+      quantity: 1
+    }]
+  };
+  var additionalSubmissionData = _objectSpread(_objectSpread({}, firstSubmissionData), {}, {
+    submissionIndex: 1
+  });
+  var firstEvaluation = evaluator.evaluate(firstSubmissionData);
+  var additionalEvaluation = evaluator.evaluate(additionalSubmissionData);
+  var quantityLimits = evaluator.getQuantityLimits(firstSubmissionData);
+  var validateResult = evaluator.validateCart(firstSubmissionData);
+  var prefillItems = evaluator.getPrefillItems(firstSubmissionData);
+
+  // 按需覆盖策略：仅评估“锅底必选”规则
+  var baseOnlyEvaluation = evaluator.evaluate(_objectSpread(_objectSpread({}, firstSubmissionData), {}, {
+    strategyConfigs: [HOTPOT_BASE_REQUIRED_STRATEGY]
+  }));
+  return {
+    // configuredRuleIds: evaluator
+    //   .getStrategyConfigs()
+    //   .map((config) => config.metadata.id),
+    firstEvaluation: firstEvaluation,
+    // additionalEvaluation,
+    // quantityLimits,
+    validateResult: validateResult,
+    prefillItems: prefillItems
+    // baseOnlyEvaluation,
+  };
+}

package/dist/model/strategy/adapter/itemRule/index.d.ts

@@ -0,0 +1,5 @@
+export { ItemRuleEvaluator } from './evaluator';
+export { ItemRuleAdapter } from './adapter';
+export { default } from './adapter';
+export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo, } from './examples';
+export * from './type';

package/dist/model/strategy/adapter/itemRule/index.js

@@ -0,0 +1,5 @@
+export { ItemRuleEvaluator } from "./evaluator";
+export { ItemRuleAdapter } from "./adapter";
+export { default } from "./adapter";
+export { MIN_CONDIMENT_PER_PERSON_STRATEGY, MAX_BUNS_PER_TABLE_STRATEGY, HOTPOT_BASE_REQUIRED_STRATEGY, quickUseItemRuleEvaluator, runItemRuleEvaluatorDemo } from "./examples";
+export * from "./type";