@pisell/pisellos 2.1.172 → 2.1.174

package/lib/modules/Rules/entitlementLines.js

@@ -0,0 +1,158 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Rules/entitlementLines.ts
+var entitlementLines_exports = {};
+__export(entitlementLines_exports, {
+  finalizeEntitlementLines: () => finalizeEntitlementLines,
+  isEntitlementRuntimeLine: () => isEntitlementRuntimeLine,
+  prepareEntitlementLines: () => prepareEntitlementLines,
+  rebuildEntitlementLine: () => rebuildEntitlementLine
+});
+module.exports = __toCommonJS(entitlementLines_exports);
+var import_lodash_es = require("lodash-es");
+var import_decimal = __toESM(require("decimal.js"));
+var import_entitlementPass = require("../Discount/entitlementPass");
+var import_entitlementState = require("../Discount/entitlementState");
+var SOURCE = "entitlement_source_identity";
+function isManualDiscount(data) {
+  var _a;
+  return data.isManualDiscount ?? (data.total != data.origin_total && (data.bundle || []).every((item) => {
+    var _a2;
+    return !((_a2 = item.discount_list) == null ? void 0 : _a2.length);
+  }) && (!((_a = data.discount_list) == null ? void 0 : _a.length) || data.discount_list.every((item) => item.type === "product")));
+}
+function isEntitlementRuntimeLine(product, mappedProduct) {
+  var _a;
+  return ((_a = product.metadata) == null ? void 0 : _a[SOURCE]) != null && !(0, import_entitlementState.isPersistedEntitlementLine)(product, mappedProduct) && !isManualDiscount(mappedProduct ?? product);
+}
+function rebuildEntitlementLine(origin, bundle, hooks, count) {
+  const data = hooks.getProduct(origin);
+  const quantity = count ?? data.quantity ?? data.num ?? 1;
+  const discounts = (data.discount_list || []).map(
+    (item) => {
+      var _a;
+      return (0, import_entitlementPass.isEntitlementPass)(item) && !((_a = item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id) ? { ...item, _num: quantity, metadata: { ...item.metadata, num: quantity } } : item;
+    }
+  );
+  const mainDiscount = discounts.filter((item) => {
+    var _a;
+    return !((_a = item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id);
+  }).reduce((sum, item) => sum.plus(item.amount || 0), new import_decimal.default(0));
+  const originalPrice = new import_decimal.default(data.original_price ?? data.price ?? 0);
+  const sourceSellingPrice = originalPrice.minus(mainDiscount).toNumber();
+  const optionPrice = (data.options || []).reduce((sum, item) => sum.plus(new import_decimal.default(item.price || 0).times(item.num || 0)), new import_decimal.default(0));
+  const bundleTotal = bundle.reduce((sum, item) => sum.plus(new import_decimal.default(item.price || 0).times(item.num || 1)), new import_decimal.default(0));
+  const bundleOriginalTotal = bundle.reduce((sum, item) => sum.plus(new import_decimal.default(item.original_price ?? item.price ?? 0).times(item.num || 1)), new import_decimal.default(0));
+  return hooks.setProduct(origin, {
+    quantity,
+    discount_list: discounts,
+    bundle,
+    price: sourceSellingPrice,
+    main_product_selling_price: sourceSellingPrice,
+    total: new import_decimal.default(sourceSellingPrice).plus(optionPrice).plus(bundleTotal).toNumber(),
+    origin_total: originalPrice.plus(optionPrice).plus(bundleOriginalTotal).toNumber()
+  });
+}
+function setLineIdentity(row, id) {
+  row._id = id;
+  row.metadata = { ...row.metadata, unique_identification_number: id };
+  if (row._extend)
+    row._extend.unique_identification_number = id;
+  return row;
+}
+function prepareEntitlementLines(products, hooks, canUseEntitlement) {
+  return products.flatMap((original) => {
+    var _a, _b, _c, _d;
+    const data = hooks.getProduct(original);
+    if ((0, import_entitlementState.isPersistedEntitlementLine)(original, data) || isManualDiscount(data))
+      return [original];
+    const applicable = canUseEntitlement(original);
+    if (!((_a = original.metadata) == null ? void 0 : _a[SOURCE]) && !(0, import_entitlementState.hasEntitlementDiscount)(data) && !applicable)
+      return [original];
+    const origin = (0, import_lodash_es.cloneDeep)(original);
+    origin.metadata = { ...origin.metadata, [SOURCE]: ((_b = origin.metadata) == null ? void 0 : _b[SOURCE]) ?? data._id };
+    const bundle = (data.bundle || []).map((item) => {
+      var _a2;
+      const entitlement = (item.discount_list || []).find(import_entitlementPass.isEntitlementPass);
+      if (!entitlement)
+        return item;
+      const discounts = (item.discount_list || []).filter((discount) => !(0, import_entitlementPass.isEntitlementPass)(discount));
+      const originalPrice = item.original_price ?? ((_a2 = entitlement.discount) == null ? void 0 : _a2.original_amount) ?? item.product_price ?? item.price ?? 0;
+      const amount = discounts.reduce((sum, discount) => sum.plus(discount.amount || 0), new import_decimal.default(0));
+      const price = new import_decimal.default(originalPrice).minus(amount.div(item.num || 1)).toNumber();
+      return { ...item, original_price: originalPrice, price, bundle_selling_price: price, discount_list: discounts };
+    });
+    const mainEntitlement = (_c = data.discount_list) == null ? void 0 : _c.find(import_entitlementPass.isEntitlementPass);
+    const restored = hooks.setProduct(origin, {
+      original_price: data.original_price ?? ((_d = mainEntitlement == null ? void 0 : mainEntitlement.discount) == null ? void 0 : _d.original_amount) ?? data.price,
+      discount_list: (data.discount_list || []).filter((item) => !(0, import_entitlementPass.isEntitlementPass)(item)),
+      bundle
+    });
+    const row = rebuildEntitlementLine(restored, bundle, hooks);
+    const count = Math.max(1, Math.floor(Number(data.quantity || data.num || 1)));
+    if (!applicable || count <= 1 || !bundle.length && !Array.isArray(data.holder_id))
+      return [row];
+    return Array.from({ length: count }, (_, index) => {
+      var _a2, _b2;
+      const unit = (0, import_lodash_es.cloneDeep)(row);
+      for (const source of [unit, unit._extend]) {
+        if (Array.isArray(source == null ? void 0 : source.holder_id))
+          source.holder_id = source.holder_id.slice(index, index + 1);
+      }
+      if (Array.isArray((_b2 = (_a2 = unit._origin) == null ? void 0 : _a2.holder) == null ? void 0 : _b2.form_record)) {
+        const records = unit._origin.holder.form_record;
+        if (records.length > 1)
+          unit._origin.holder.form_record = records.slice(index, index + 1);
+      }
+      return setLineIdentity(rebuildEntitlementLine(unit, hooks.getProduct(unit).bundle || [], hooks, 1), `${data._id}:entitlement-unit:${index}`);
+    });
+  });
+}
+function finalizeEntitlementLines(products, hooks) {
+  const runtime = (item) => isEntitlementRuntimeLine(item, hooks.getProduct(item));
+  const seen = new Set(products.filter((item) => !runtime(item)).map((item) => String(item._id)));
+  return products.map((origin, index) => {
+    if (!runtime(origin))
+      return origin;
+    const base = String(origin._id ?? hooks.getProduct(origin)._id);
+    let id = base;
+    let ordinal = index;
+    while (seen.has(id))
+      id = `${base}:entitlement-split:${ordinal++}`;
+    seen.add(id);
+    return id === String(origin._id) ? origin : setLineIdentity((0, import_lodash_es.cloneDeep)(origin), id);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finalizeEntitlementLines,
+  isEntitlementRuntimeLine,
+  prepareEntitlementLines,
+  rebuildEntitlementLine
+});

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

@@ -1,49 +1,55 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
 import { Rules, RulesModuleAPI, DiscountResult, UnavailableReason } from './types';
-import { Discount } from '../Discount/types';
-import { WindowPlugin } from '../../plugins';
+import { Discount } from "../Discount/types";
+import { SetDiscountSelectedParams } from '../../solution/ShopDiscount/types';
 export declare class RulesModule extends BaseModule implements Module, RulesModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
     private store;
-    window: WindowPlugin;
     private hooks;
+    private entitlementPassEnabled;
+    private defaultWalletPassEvaluator?;
+    setEntitlementPassEnabled(enabled: boolean): void;
+    private getWalletPassEvaluator;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
     setRulesList(rulesList: Rules[]): Promise<void>;
     getRulesList(): Rules[];
+    private normalizeHolderRecordIds;
+    /**
+     * 商品未开启 Holder 选择时跳过匹配；已开启时，特定 form Holder 卡
+     * 只适用于同一 Holder Record，是否必填不影响匹配规则。
+     */
     private checkHolderMatch;
-    getWalletPassEvaluator(): import("../..").WalletPassEvaluator | undefined;
-    isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, orderTotalAmount, holders, isFormSubject, }: {
+    isDiscountListAvailable({ oldDiscountList, newDiscountList, productList, holders, isFormSubject, }: {
         oldDiscountList: Discount[];
         newDiscountList: Discount[];
         productList: any[];
         holders: {
-            form_record_id: number;
+            form_record_id: number | string;
         }[];
-        orderTotalAmount: number;
         isFormSubject: boolean;
     }): {
         isAvailable: boolean;
         discountList: Discount[];
         productList: any[];
         unavailableReason?: UnavailableReason;
+        evaluatedDiscountList?: Discount[];
     };
     filterDiscountListByType(discountList: Discount[], type: string): Discount[];
     private getUnavailableReason;
-    calcDiscount({ discountList, productList, holders, isFormSubject, orderTotalAmount }: {
+    calcDiscount({ discountList, productList, holders, isFormSubject, }: {
         discountList: Discount[];
         productList: any[];
         holders: {
-            form_record_id: number;
+            form_record_id: number | string;
         }[];
         isFormSubject: boolean;
-        orderTotalAmount: number;
     }, options?: {
         isSelected?: boolean;
         discountId?: number;
-        selectedList?: any[];
+        selectedList?: SetDiscountSelectedParams[];
         scan?: boolean;
     }): DiscountResult;
     /**