@pisell/pisellos 2.1.118 → 2.1.120

package/lib/model/strategy/index.js

@@ -20,394 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/model/strategy/index.ts
 var strategy_exports = {};
 __export(strategy_exports, {
-  StrategyEngine: () => StrategyEngine,
-  createStrategyEngine: () => createStrategyEngine,
-  evaluate: () => evaluate
+  StrategyEngine: () => import_engine.StrategyEngine,
+  createStrategyEngine: () => import_engine.createStrategyEngine,
+  evaluate: () => import_engine.evaluate
 });
 module.exports = __toCommonJS(strategy_exports);
-var import_type = require("./type");
+var import_engine = require("./engine");
+__reExport(strategy_exports, require("./type"), module.exports);
 __reExport(strategy_exports, require("./adapter"), module.exports);
-var StrategyEngine = class {
-  constructor(options = {}) {
-    this.options = {
-      debug: options.debug ?? false,
-      enableTrace: options.enableTrace ?? false,
-      operatorHandlers: options.operatorHandlers ?? {},
-      errorHandler: options.errorHandler ?? ((error) => console.error(error))
-    };
-    this.operatorHandlers = new Map(
-      Object.entries(this.options.operatorHandlers)
-    );
-    this.initializeBuiltInOperators();
-  }
-  /**
-   * 评估策略
-   */
-  evaluate(config, context) {
-    var _a;
-    const startTime = Date.now();
-    const trace = {
-      steps: [],
-      duration: 0,
-      errors: []
-    };
-    try {
-      this.validateConfig(config);
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "validate_config",
-          status: "success",
-          duration: Date.now() - startTime
-        });
-      }
-      const evaluateStart = Date.now();
-      const evaluationResult = this.evaluateConditionGroup(
-        config.conditions,
-        context
-      );
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "evaluate_conditions",
-          status: "success",
-          duration: Date.now() - evaluateStart,
-          details: {
-            satisfied: evaluationResult.satisfied,
-            collectedActionIds: evaluationResult.actionIds
-          }
-        });
-      }
-      const actionStart = Date.now();
-      const matchedActions = this.getActionsByIds(
-        evaluationResult.actionIds,
-        config.actions
-      );
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "get_actions",
-          status: "success",
-          duration: Date.now() - actionStart,
-          details: { matchedCount: matchedActions.length }
-        });
-      }
-      const sortStart = Date.now();
-      const sortedActions = this.sortActionsByPriority(matchedActions);
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "sort_actions",
-          status: "success",
-          duration: Date.now() - sortStart
-        });
-      }
-      const applicable = evaluationResult.satisfied;
-      const result = {
-        success: true,
-        applicable,
-        code: applicable ? import_type.SUCCESS_CODES.SUCCESS : import_type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
-        message: applicable ? "Strategy is applicable" : "Conditions not met",
-        matched: {
-          conditions: applicable,
-          actionIds: evaluationResult.actionIds,
-          details: {}
-        },
-        matchedActions: sortedActions,
-        outputs: {},
-        config
-      };
-      trace.duration = Date.now() - startTime;
-      if (this.options.enableTrace) {
-        result.trace = trace;
-      }
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (this.options.enableTrace) {
-        (_a = trace.errors) == null ? void 0 : _a.push({
-          step: "evaluation",
-          error: errorMessage,
-          timestamp: Date.now()
-        });
-        trace.duration = Date.now() - startTime;
-      }
-      this.options.errorHandler(error, context);
-      return {
-        success: false,
-        applicable: false,
-        code: import_type.ERROR_CODES.EVALUATION_ERROR,
-        message: errorMessage,
-        matched: {
-          conditions: false,
-          actionIds: [],
-          details: {}
-        },
-        matchedActions: [],
-        outputs: {},
-        trace: this.options.enableTrace ? trace : void 0,
-        config
-      };
-    }
-  }
-  /**
-   * 递归评估条件组
-   *
-   * @param group 条件组
-   * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
-   */
-  evaluateConditionGroup(group, context) {
-    const collectedActionIds = [];
-    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-    if (isCurrentLayerSatisfied) {
-      collectedActionIds.push(...group.actionIds);
-      for (const rule of group.rules) {
-        if (this.isConditionGroup(rule)) {
-          const nestedResult = this.evaluateConditionGroup(rule, context);
-          collectedActionIds.push(...nestedResult.actionIds);
-        }
-      }
-    }
-    return {
-      satisfied: isCurrentLayerSatisfied,
-      actionIds: collectedActionIds
-    };
-  }
-  /**
-   * 评估条件组的逻辑运算
-   */
-  evaluateGroupLogic(group, context) {
-    const { operator, rules } = group;
-    switch (operator) {
-      case "and":
-        return rules.every((rule) => this.evaluateRule(rule, context));
-      case "or":
-        return rules.some((rule) => this.evaluateRule(rule, context));
-      case "not":
-        if (rules.length === 0)
-          return false;
-        return !this.evaluateRule(rules[0], context);
-      default:
-        throw new Error(`Unknown operator: ${operator}`);
-    }
-  }
-  /**
-   * 评估单个规则
-   */
-  evaluateRule(rule, context) {
-    if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogic(rule, context);
-    }
-    const conditionRule = rule;
-    if (conditionRule.type === "code" && conditionRule.code) {
-      return this.evaluateCodeCondition(conditionRule.code, context);
-    }
-    return this.evaluateOperatorCondition(conditionRule, context);
-  }
-  /**
-   * 评估代码模式条件
-   */
-  evaluateCodeCondition(code, context) {
-    try {
-      const { entities, attributes, metadata } = context;
-      const evalFunc = new Function(
-        "entities",
-        "attributes",
-        "metadata",
-        `return (${code})`
-      );
-      const result = evalFunc(entities, attributes, metadata);
-      return Boolean(result);
-    } catch (error) {
-      if (this.options.debug) {
-        console.error("Code evaluation error:", error);
-      }
-      return false;
-    }
-  }
-  /**
-   * 评估运算符模式条件
-   */
-  evaluateOperatorCondition(rule, context) {
-    const { field, operator, value } = rule;
-    if (!field || !operator) {
-      return false;
-    }
-    const fieldValue = this.getFieldValue(field, context);
-    const handler = this.operatorHandlers.get(operator);
-    if (handler) {
-      return handler(fieldValue, value, rule);
-    }
-    return this.evaluateBuiltInOperator(fieldValue, operator, value);
-  }
-  /**
-   * 获取字段值
-   */
-  getFieldValue(field, context) {
-    const path = field.split(".");
-    let value = context.attributes;
-    for (const key of path) {
-      if (value && typeof value === "object" && key in value) {
-        value = value[key];
-      } else {
-        return void 0;
-      }
-    }
-    return value;
-  }
-  /**
-   * 评估内置运算符
-   */
-  evaluateBuiltInOperator(fieldValue, operator, compareValue) {
-    switch (operator) {
-      case "=":
-      case "==":
-        return fieldValue == compareValue;
-      case "!=":
-        return fieldValue != compareValue;
-      case ">":
-        return fieldValue > compareValue;
-      case ">=":
-        return fieldValue >= compareValue;
-      case "<":
-        return fieldValue < compareValue;
-      case "<=":
-        return fieldValue <= compareValue;
-      case "in":
-        return Array.isArray(compareValue) && compareValue.includes(fieldValue);
-      case "not_in":
-        return Array.isArray(compareValue) && !compareValue.includes(fieldValue);
-      case "contains":
-        if (Array.isArray(fieldValue)) {
-          return fieldValue.includes(compareValue);
-        }
-        if (typeof fieldValue === "string") {
-          return fieldValue.includes(compareValue);
-        }
-        return false;
-      case "not_contains":
-        if (Array.isArray(fieldValue)) {
-          return !fieldValue.includes(compareValue);
-        }
-        if (typeof fieldValue === "string") {
-          return !fieldValue.includes(compareValue);
-        }
-        return true;
-      case "starts_with":
-        return typeof fieldValue === "string" && fieldValue.startsWith(compareValue);
-      case "ends_with":
-        return typeof fieldValue === "string" && fieldValue.endsWith(compareValue);
-      case "regex":
-        return typeof fieldValue === "string" && new RegExp(compareValue).test(fieldValue);
-      case "between":
-        if (!Array.isArray(compareValue) || compareValue.length !== 2)
-          return false;
-        return fieldValue >= compareValue[0] && fieldValue <= compareValue[1];
-      case "is_null":
-        return fieldValue === null || fieldValue === void 0;
-      case "is_not_null":
-        return fieldValue !== null && fieldValue !== void 0;
-      case "is_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length === 0;
-        return !fieldValue;
-      case "is_not_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length > 0;
-        return Boolean(fieldValue);
-      default:
-        throw new Error(`Unsupported operator: ${operator}`);
-    }
-  }
-  /**
-   * 根据 actionIds 获取 ActionEffect 对象
-   */
-  getActionsByIds(actionIds, actions) {
-    const matchedActions = [];
-    const actionMap = new Map(actions.map((action) => [action.id, action]));
-    for (const id of actionIds) {
-      const action = actionMap.get(id);
-      if (action) {
-        matchedActions.push(action);
-      } else {
-        if (this.options.debug) {
-          console.warn(`Action with id "${id}" not found in actions array`);
-        }
-      }
-    }
-    return matchedActions;
-  }
-  /**
-   * 按 priority 排序（降序）
-   */
-  sortActionsByPriority(actions) {
-    return [...actions].sort((a, b) => {
-      const priorityA = a.priority ?? 0;
-      const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
-    });
-  }
-  /**
-   * 判断是否为条件组
-   */
-  isConditionGroup(rule) {
-    return "operator" in rule && "rules" in rule && Array.isArray(rule.rules);
-  }
-  /**
-   * 验证配置
-   */
-  validateConfig(config) {
-    if (!config) {
-      throw new Error("Strategy config is required");
-    }
-    if (!config.metadata || !config.metadata.id) {
-      throw new Error("Strategy metadata.id is required");
-    }
-    if (!config.conditions) {
-      throw new Error("Strategy conditions is required");
-    }
-    if (!Array.isArray(config.actions)) {
-      throw new Error("Strategy actions must be an array");
-    }
-  }
-  /**
-   * 初始化内置运算符处理器
-   */
-  initializeBuiltInOperators() {
-  }
-  /**
-   * 注册自定义运算符
-   */
-  registerOperator(operator, handler) {
-    this.operatorHandlers.set(operator, handler);
-  }
-  /**
-   * 获取调试信息
-   */
-  getDebugInfo() {
-    return {
-      debug: this.options.debug,
-      enableTrace: this.options.enableTrace,
-      registeredOperators: Array.from(this.operatorHandlers.keys())
-    };
-  }
-};
-function createStrategyEngine(options) {
-  return new StrategyEngine(options);
-}
-function evaluate(config, context) {
-  const engine = new StrategyEngine();
-  return engine.evaluate(config, context);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StrategyEngine,
   createStrategyEngine,
   evaluate,
+  ...require("./type"),
   ...require("./adapter")
 });

package/lib/modules/Cart/types.d.ts

@@ -75,8 +75,6 @@ export interface CartItem {
     summaryTotal?: number | string;
     /** 商品原价总价，排除原始价格为0的场景 */
     origin_total?: number | string;
-    /** 基于 origin_total 乘以 商品数量的价格 */
-    summaryOriginTotal?: number | string;
     /** 商品数量 */
     num?: number;
     /** 商品图片 */

package/lib/modules/Cart/utils/cartProduct.js

@@ -46,18 +46,6 @@ var import_decimal = __toESM(require("decimal.js"));
 var import_utils = require("../../Product/utils");
 var import_utils2 = require("../../../solution/ShopDiscount/utils");
 var import_utils3 = require("../../Summary/utils");
-var toDiscountPayload = (discountItem) => {
-  var _a, _b;
-  return {
-    amount: discountItem.amount,
-    tag: discountItem.type,
-    par_value: (_a = discountItem.discount) == null ? void 0 : _a.percent,
-    config: discountItem.config,
-    metadata: {
-      discount_card_type: (_b = discountItem == null ? void 0 : discountItem.discount) == null ? void 0 : _b.discount_card_type
-    }
-  };
-};
 var handleVariantProduct = (product) => {
   var _a;
   if (product == null ? void 0 : product.product_variant_id) {
@@ -102,14 +90,6 @@ var formatProductToCartItem = (params) => {
       num,
       discounts
     });
-    const origin_total = getProductTotalPrice({
-      product: cartItem._productInit || cartItem._productOrigin,
-      bundle,
-      options,
-      num,
-      discounts: []
-    });
-    cartItem.summaryOriginTotal = (origin_total || 0) * (num || 1);
     cartItem.image = product == null ? void 0 : product.cover;
     cartItem.like_status = "common";
     cartItem.duration = product == null ? void 0 : product.duration;
@@ -204,24 +184,17 @@ var formatProductToCartItemOrigin = (params) => {
 var getProductTotalPrice = (params) => {
   const { product, bundle, options, discounts } = params;
   let price = Number(product.price);
-  const optionRows = (options == null ? void 0 : options.map((currentValue) => ({
-    unit: Number(currentValue.price ?? currentValue.add_price ?? 0),
-    num: Number(currentValue.num ?? currentValue.quantity ?? 1)
-  }))) ?? [];
   if (discounts == null ? void 0 : discounts.length) {
     discounts.forEach((currentValue) => {
       var _a;
-      const payload = toDiscountPayload(currentValue);
-      price = (0, import_utils2.getDiscountAmount)(payload, price, price);
-      if (((_a = currentValue == null ? void 0 : currentValue.config) == null ? void 0 : _a.deductOptionPrice) && optionRows.length) {
-        for (let i = 0; i < optionRows.length; i++) {
-          const row = optionRows[i];
-          optionRows[i] = {
-            ...row,
-            unit: (0, import_utils2.getDiscountAmount)(payload, row.unit, row.unit)
-          };
+      price = (0, import_utils2.getDiscountAmount)({
+        amount: currentValue.amount,
+        tag: currentValue.type,
+        par_value: currentValue.discount.percent,
+        metadata: {
+          discount_card_type: (_a = currentValue == null ? void 0 : currentValue.discount) == null ? void 0 : _a.discount_card_type
         }
-      }
+      }, price, price);
     });
   }
   if (bundle == null ? void 0 : bundle.length) {
@@ -229,11 +202,10 @@ var getProductTotalPrice = (params) => {
       return accumulator + Number(currentValue.price) * Number(currentValue.num);
     }, price);
   }
-  if (optionRows.length) {
-    price = optionRows.reduce(
-      (accumulator, row) => accumulator + row.unit * row.num,
-      price
-    );
+  if (options == null ? void 0 : options.length) {
+    price = options.reduce((accumulator, currentValue) => {
+      return accumulator + Number(currentValue.price) * Number(currentValue.num);
+    }, price);
   }
   return Math.max(0, price);
 };
@@ -341,6 +313,7 @@ var formatBundleToOrigin = (bundle) => {
       option: formatOptionsToOrigin(getBundleValueByKey("option")),
       discount_list: d.discount_list,
       "bundle_selling_price": d == null ? void 0 : d.price,
+      "custom_price": d == null ? void 0 : d.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference

package/lib/modules/Discount/types.d.ts

@@ -33,8 +33,6 @@ interface Limitedrelationproductdata {
     product_ids: number[];
     product_collection_id: number[];
     package_sub_item_usage_rules?: PackageSubItemUsageRules;
-    filter: 0 | 1;
-    exclude_product_ids: number[];
 }
 interface ApplicableProductDetails {
     amount: string;
@@ -91,7 +89,6 @@ export interface Discount {
     balance: string;
     format_title: Formattitle;
     metadata?: {
-        num?: number;
         discount_card_type?: 'fixed_amount' | 'percent';
         custom_product_bundle_map_id?: string;
         validity_type?: "custom_schedule_validity" | "fixed_validity";
@@ -116,21 +113,6 @@ export interface Discount {
     isSelected?: boolean;
     isAvailable?: boolean;
     isUsed?: boolean;
-    config?: {
-        isAvailable?: boolean;
-        /** 最大抵扣金额 */
-        maxDeductionAmount?: number;
-        /** 每单最多使用张数 */
-        maxUsagePerOrder?: number;
-        /** 是否抵扣税费与附加费 */
-        deductTaxAndFee?: boolean;
-        /** 适用粒度（多商品共用） */
-        allowCrossProduct?: boolean;
-        /** 可用商品数量上限 */
-        applicableProductLimit?: number;
-        /** 是否抵扣单规格价格 (Option Price) */
-        deductOptionPrice?: boolean;
-    };
     applicableProductIds?: number[];
     applicableProductDetails: ApplicableProductDetails[];
     appliedProductDetails: ApplicableProductDetails[];

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

@@ -0,0 +1,23 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { BaseModule } from '../BaseModule';
+import type { ScheduleModule } from '../Schedule';
+import type { OpenDataConfig, OpenDataFetchParams, OpenDataAvailabilityResult } from './types';
+export * from './types';
+export { computeAvailability } from './utils';
+export declare class OpenDataModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private window;
+    private store;
+    private cacheId;
+    private openCache;
+    private fatherModule;
+    private otherParams;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    fetchOpenData(params: OpenDataFetchParams): Promise<OpenDataConfig>;
+    getOpenData(): OpenDataConfig | null;
+    checkAvailability(scheduleModule?: ScheduleModule): OpenDataAvailabilityResult;
+    storeChange(): void;
+}

package/lib/modules/OpenData/index.js

@@ -0,0 +1,116 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/OpenData/index.ts
+var OpenData_exports = {};
+__export(OpenData_exports, {
+  OpenDataModule: () => OpenDataModule,
+  computeAvailability: () => import_utils2.computeAvailability
+});
+module.exports = __toCommonJS(OpenData_exports);
+var import_BaseModule = require("../BaseModule");
+var import_utils = require("./utils");
+__reExport(OpenData_exports, require("./types"), module.exports);
+var import_utils2 = require("./utils");
+var OpenDataModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "openData";
+    this.defaultVersion = "1.0.0";
+    this.openCache = false;
+    this.otherParams = {};
+  }
+  async initialize(core, options) {
+    var _a, _b;
+    this.core = core;
+    this.store = options.store;
+    this.store.data = ((_a = options.initialState) == null ? void 0 : _a.data) ?? null;
+    this.store.lastFetchedAt = ((_b = options.initialState) == null ? void 0 : _b.lastFetchedAt) ?? null;
+    this.otherParams = options.otherParams || {};
+    if (this.otherParams.cacheId) {
+      this.openCache = this.otherParams.openCache ?? false;
+      this.cacheId = this.otherParams.cacheId;
+    }
+    if (this.otherParams.fatherModule) {
+      this.fatherModule = this.otherParams.fatherModule;
+    }
+    this.request = core.getPlugin("request");
+    this.window = core.getPlugin("window");
+    if (!this.request)
+      throw new Error("OpenDataModule 需要 request 插件支持");
+    if (!this.window)
+      throw new Error("OpenDataModule 需要 window 插件支持");
+    console.log("[OpenDataModule] 初始化完成");
+  }
+  async fetchOpenData(params) {
+    var _a, _b, _c, _d;
+    const shopId = (_b = (_a = this.otherParams) == null ? void 0 : _a.getStateData) == null ? void 0 : _b.call(_a, "shop_id");
+    if (!shopId)
+      throw new Error("[OpenDataModule] 无法获取 shop_id");
+    const tenantId = (_d = (_c = this.otherParams) == null ? void 0 : _c.getStateData) == null ? void 0 : _d.call(_c, "tenant_id");
+    const headers = {};
+    if (tenantId)
+      headers["Tenant-Id"] = String(tenantId);
+    const response = await this.request.post(
+      `/open/my-pisell/${shopId}/setting`,
+      {
+        scope: params.scope,
+        target: params.target,
+        section_code: params.section_code
+      },
+      { pisell2: true, headers }
+    );
+    if ((response == null ? void 0 : response.status) === false) {
+      throw new Error((response == null ? void 0 : response.message) || "获取 OpenData 配置失败");
+    }
+    const data = (response == null ? void 0 : response.data) || {};
+    this.store.data = data;
+    this.store.lastFetchedAt = Date.now();
+    return data;
+  }
+  getOpenData() {
+    return this.store.data;
+  }
+  checkAvailability(scheduleModule) {
+    var _a;
+    const scheduleList = scheduleModule ? scheduleModule.getScheduleListByIds(
+      ((_a = this.store.data) == null ? void 0 : _a["availability.operating_hours"]) || []
+    ) : void 0;
+    return (0, import_utils.computeAvailability)({
+      config: this.store.data,
+      scheduleList
+    });
+  }
+  storeChange() {
+    if (this.openCache) {
+      this.checkSaveCache({
+        cacheId: this.cacheId,
+        fatherModule: this.fatherModule,
+        store: this.store,
+        cacheKey: ["data", "lastFetchedAt"]
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenDataModule,
+  computeAvailability,
+  ...require("./types")
+});