@zauru-sdk/common 6.6.0 → 6.8.0

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.8.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.7.0...@zauru-sdk/common@6.8.0) (2026-09-18)
+
+
+### Features
+
+* descuento sucesivo en porcentajes de rechazo ([c437bbd](https://github.com/intuitiva/zauru-typescript-sdk/commit/c437bbd6a1305fd417c4ac55f8e07eb244f2fe3d))
+
+
+
+
+
+# [6.7.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.6.0...@zauru-sdk/common@6.7.0) (2026-09-18)
+
+
+### Features
+
+* registrar reglas automáticas de % rechazo en el historial ([4784849](https://github.com/intuitiva/zauru-typescript-sdk/commit/4784849904f9ac6570e60543895a858dece8e039))
+
+
+
+
+
 # [6.6.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.5.0...@zauru-sdk/common@6.6.0) (2026-09-14)
 
 

package/dist/common.d.ts

@@ -1,5 +1,5 @@
 import "moment-timezone";
-import type { PayeeGraphQL, AxiosUtilsResponse, BasketSchema, SelectFieldOption, JsonMemoType, CalculatePurchaseOrderFinancialsInput, CalculatePurchaseOrderFinancialsResult } from "@zauru-sdk/types";
+import type { PayeeGraphQL, AxiosUtilsResponse, BasketSchema, SelectFieldOption, JsonMemoType, CalculatePurchaseOrderFinancialsInput, CalculatePurchaseOrderFinancialsResult, RejectionPercentageLayers } from "@zauru-sdk/types";
 export declare const DESTINOS_MUESTRA_OPTIONS: SelectFieldOption[];
 export declare const parseJsonMemo: (memo?: string | object) => JsonMemoType;
 export declare const stringifyJsonMemo: (memo: JsonMemoType) => string;
@@ -12,20 +12,30 @@ export declare const getRejectionPercentage: (source: string | {
     memo?: string | object;
 } | JsonMemoType | undefined) => number;
 export declare const setRejectionPercentage: (memo: string | object | undefined, percentage: number) => string;
+/**
+ * User rejection layers (before automatic rules). Legacy memos without
+ * `rejectionLayers` use the stored origin as additive and no successive rates.
+ */
+export declare const resolveRejectionPercentageLayers: (memo?: string | object | JsonMemoType, fallbackAdditive?: number) => RejectionPercentageLayers;
+export declare const getRejectionPercentageLayers: (source: string | {
+    memo?: string | object;
+} | JsonMemoType | undefined) => RejectionPercentageLayers;
+export declare const hasSuccessiveRejectionPercentage: (source: string | {
+    memo?: string | object;
+} | JsonMemoType | undefined) => boolean;
 /**
  * Rejection % of origin stored in the memo, ignoring the adjustment rules
  * already applied on top of it.
  */
 export declare const resolveRejectionPercentageBase: (memo?: string | object) => number;
 /**
- * Header money for a purchase order: subtotal = qty × unit_cost,
- * discount = subtotal × rejectionPercentage / 100.
+ * Header money for a purchase order: subtotal = qty × unit_cost.
+ * Additive rates are summed first; successive rates then apply to the remainder.
  * Does not change unit cost. purchase_orders.discount is the monetary column.
  *
- * If `rules` is given, the rejection % is resolved back to the origin stored in
- * the memo and the rules are stacked on top of it before calculating the money.
- * `rejectionPercentage` in the result is the % that was actually charged and
- * `rejectionCalculations` is the trace to store in the memo.
+ * User layers (before rules) are returned as `rejectionLayers` for the memo.
+ * Automatic rules add percentage points on the additive block only.
+ * `rejectionPercentage` in the result is the effective % that was charged.
  */
 export declare const calculatePurchaseOrderFinancials: (input: CalculatePurchaseOrderFinancialsInput) => CalculatePurchaseOrderFinancialsResult;
 /**

package/dist/esm/common.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsedObject = exports.sortByProperty = exports.labFormPatter = exports.labServicePattern = exports.getRandomNum = exports.CURRENCY_PREFIX = exports.truncateDecimals = exports.ZAURU_REGEX = exports.priceToText = exports.arrayToObject = exports.isNumeric = exports.toFixedIfNeeded = exports.formatTimeToTimePicker = exports.formatDateToDatePicker = exports.getFormattedDate = exports.parsedBaculoFormValue = exports.getPayeeInfoOptions = exports.getPayeeInfoIdOptions = exports.getPayeeFormated = exports.getDateAfterDays = exports.getTimePickerCurrentTime = exports.obtenerFechaActualConZonaHoraria = exports.getDatePickerCurrentDate = exports.stringDateToParsedUTCDate = exports.localDateToUSDate = exports.getStringFullDate = exports.getTodayMinutesDifference = exports.getTodayDaysDifference = exports.getStringDate = exports.getZauruDateByText = exports.getNewDateByFormat = exports.getFechaJuliana = exports.getBasketsSchema = exports.calculatePurchaseOrderFinancials = exports.resolveRejectionPercentageBase = exports.setRejectionPercentage = exports.getRejectionPercentage = exports.mergeJsonMemo = exports.stringifyJsonMemo = exports.parseJsonMemo = exports.DESTINOS_MUESTRA_OPTIONS = void 0;
+exports.parsedObject = exports.sortByProperty = exports.labFormPatter = exports.labServicePattern = exports.getRandomNum = exports.CURRENCY_PREFIX = exports.truncateDecimals = exports.ZAURU_REGEX = exports.priceToText = exports.arrayToObject = exports.isNumeric = exports.toFixedIfNeeded = exports.formatTimeToTimePicker = exports.formatDateToDatePicker = exports.getFormattedDate = exports.parsedBaculoFormValue = exports.getPayeeInfoOptions = exports.getPayeeInfoIdOptions = exports.getPayeeFormated = exports.getDateAfterDays = exports.getTimePickerCurrentTime = exports.obtenerFechaActualConZonaHoraria = exports.getDatePickerCurrentDate = exports.stringDateToParsedUTCDate = exports.localDateToUSDate = exports.getStringFullDate = exports.getTodayMinutesDifference = exports.getTodayDaysDifference = exports.getStringDate = exports.getZauruDateByText = exports.getNewDateByFormat = exports.getFechaJuliana = exports.getBasketsSchema = exports.calculatePurchaseOrderFinancials = exports.resolveRejectionPercentageBase = exports.hasSuccessiveRejectionPercentage = exports.getRejectionPercentageLayers = exports.resolveRejectionPercentageLayers = exports.setRejectionPercentage = exports.getRejectionPercentage = exports.mergeJsonMemo = exports.stringifyJsonMemo = exports.parseJsonMemo = exports.DESTINOS_MUESTRA_OPTIONS = void 0;
 exports.generateClientUUID = generateClientUUID;
 exports.extractValueBetweenTags = extractValueBetweenTags;
 exports.isJsonArray = isJsonArray;
@@ -81,11 +81,44 @@ const getRejectionPercentage = (source) => {
 exports.getRejectionPercentage = getRejectionPercentage;
 const setRejectionPercentage = (memo, percentage) => (0, exports.mergeJsonMemo)(memo, { rejectionPercentage: percentage });
 exports.setRejectionPercentage = setRejectionPercentage;
+const memoFromRejectionSource = (source) => {
+    if (source == null || source === "")
+        return {};
+    if (typeof source === "string")
+        return (0, exports.parseJsonMemo)(source);
+    if (typeof source !== "object")
+        return {};
+    const record = source;
+    if (record.memo != null && record.memo !== "") {
+        return (0, exports.parseJsonMemo)(record.memo);
+    }
+    return (0, exports.parseJsonMemo)(record);
+};
+/**
+ * User rejection layers (before automatic rules). Legacy memos without
+ * `rejectionLayers` use the stored origin as additive and no successive rates.
+ */
+const resolveRejectionPercentageLayers = (memo, fallbackAdditive) => {
+    const parsed = (0, exports.parseJsonMemo)(memo);
+    if (parsed.rejectionLayers) {
+        return (0, rejectionPercentageAdjustment_js_1.normalizeRejectionPercentageLayers)(parsed.rejectionLayers);
+    }
+    const origin = (0, rejectionPercentageAdjustment_js_1.resolveRejectionPercentageOrigin)(fallbackAdditive ?? (0, exports.getRejectionPercentage)(parsed), parsed.rejectionCalculations);
+    return (0, rejectionPercentageAdjustment_js_1.normalizeRejectionPercentageLayers)({
+        additive: origin,
+        successive: [],
+    });
+};
+exports.resolveRejectionPercentageLayers = resolveRejectionPercentageLayers;
+const getRejectionPercentageLayers = (source) => (0, exports.resolveRejectionPercentageLayers)(memoFromRejectionSource(source));
+exports.getRejectionPercentageLayers = getRejectionPercentageLayers;
+const hasSuccessiveRejectionPercentage = (source) => (0, rejectionPercentageAdjustment_js_1.hasSuccessiveRejectionLayers)((0, exports.getRejectionPercentageLayers)(source));
+exports.hasSuccessiveRejectionPercentage = hasSuccessiveRejectionPercentage;
 /**
  * Rejection % of origin stored in the memo, ignoring the adjustment rules
  * already applied on top of it.
  */
-const resolveRejectionPercentageBase = (memo) => (0, rejectionPercentageAdjustment_js_1.resolveRejectionPercentageOrigin)((0, exports.getRejectionPercentage)(memo), (0, exports.parseJsonMemo)(memo).rejectionCalculations);
+const resolveRejectionPercentageBase = (memo) => (0, exports.resolveRejectionPercentageLayers)(memo).additive;
 exports.resolveRejectionPercentageBase = resolveRejectionPercentageBase;
 const roundMoney = (value) => Math.round((value + Number.EPSILON) * 100) / 100;
 const lineQuantity = (detail) => {
@@ -99,14 +132,13 @@ const lineQuantity = (detail) => {
         0);
 };
 /**
- * Header money for a purchase order: subtotal = qty × unit_cost,
- * discount = subtotal × rejectionPercentage / 100.
+ * Header money for a purchase order: subtotal = qty × unit_cost.
+ * Additive rates are summed first; successive rates then apply to the remainder.
  * Does not change unit cost. purchase_orders.discount is the monetary column.
  *
- * If `rules` is given, the rejection % is resolved back to the origin stored in
- * the memo and the rules are stacked on top of it before calculating the money.
- * `rejectionPercentage` in the result is the % that was actually charged and
- * `rejectionCalculations` is the trace to store in the memo.
+ * User layers (before rules) are returned as `rejectionLayers` for the memo.
+ * Automatic rules add percentage points on the additive block only.
+ * `rejectionPercentage` in the result is the effective % that was charged.
  */
 const calculatePurchaseOrderFinancials = (input) => {
     const details = input.details ?? [];
@@ -115,17 +147,28 @@ const calculatePurchaseOrderFinancials = (input) => {
         return sum + lineQuantity(detail) * unitCost;
     }, 0));
     const safeSubtotal = Number.isFinite(subtotal) ? subtotal : 0;
-    const passedPercentage = toFiniteNumber(input.rejectionPercentage) ?? 0;
+    const parsedMemo = (0, exports.parseJsonMemo)(input.memo);
+    let userLayers = input.rejectionLayers
+        ? (0, rejectionPercentageAdjustment_js_1.normalizeRejectionPercentageLayers)(input.rejectionLayers)
+        : (0, exports.resolveRejectionPercentageLayers)(parsedMemo, toFiniteNumber(input.rejectionPercentage));
+    if (input.rejectionApplication) {
+        userLayers = (0, rejectionPercentageAdjustment_js_1.applyRejectionPercentageLayers)(userLayers, input.rejectionApplication);
+    }
     const rejectionCalculations = input.rules
-        ? (0, rejectionPercentageAdjustment_js_1.applyRejectionPercentageAdjustmentRules)((0, rejectionPercentageAdjustment_js_1.resolveRejectionPercentageOrigin)(passedPercentage, (0, exports.parseJsonMemo)(input.memo).rejectionCalculations), input.rules, input.ctx ?? { itemIds: [] })
+        ? (0, rejectionPercentageAdjustment_js_1.applyRejectionPercentageAdjustmentRules)(userLayers.additive, input.rules, input.ctx ?? { itemIds: [] })
         : undefined;
-    const rejectionPercentage = rejectionCalculations?.finalPercentage ?? passedPercentage;
+    const chargedLayers = {
+        additive: rejectionCalculations?.finalPercentage ?? userLayers.additive,
+        successive: userLayers.successive,
+    };
+    const rejectionPercentage = (0, rejectionPercentageAdjustment_js_1.computeEffectiveRejectionPercentage)(chargedLayers);
     return {
         subtotal: safeSubtotal,
-        discount: rejectionPercentage > 0 && safeSubtotal > 0
+        discount: rejectionPercentage !== 0 && safeSubtotal > 0
             ? roundMoney(safeSubtotal * (rejectionPercentage / 100))
             : 0,
         rejectionPercentage,
+        rejectionLayers: userLayers,
         rejectionCalculations,
     };
 };

package/dist/esm/rejectionPercentageAdjustment.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyRejectionPercentageAdjustmentRules = exports.resolveRejectionPercentageOrigin = exports.formatRejectionPercentageAdjustmentDescription = exports.rejectionPercentageAdjustmentRuleMatches = exports.filterActiveRejectionPercentageAdjustmentRules = exports.REJECTION_PERCENTAGE_ADJUSTMENT_RULES_TABLE_VAR = void 0;
+exports.applyRejectionPercentageAdjustmentRules = exports.isAutomaticRejectionRuleHistoryType = exports.formatAutomaticRejectionRuleHistoryDescription = exports.getNewlyAppliedRejectionRuleSteps = exports.rejectionRuleStepKey = exports.resolveRejectionPercentageOrigin = exports.formatRejectionPercentageAdjustmentDescription = exports.hasSuccessiveRejectionLayers = exports.computeEffectiveRejectionPercentage = exports.applyRejectionPercentageLayers = exports.normalizeRejectionPercentageLayers = exports.rejectionPercentageAdjustmentRuleMatches = exports.filterActiveRejectionPercentageAdjustmentRules = exports.REJECTION_PERCENTAGE_RULE_HISTORY_TYPE = exports.REJECTION_PERCENTAGE_ADJUSTMENT_RULES_TABLE_VAR = void 0;
 exports.REJECTION_PERCENTAGE_ADJUSTMENT_RULES_TABLE_VAR = "rejection_percentage_adjustment_rules_web_app_table_id";
+exports.REJECTION_PERCENTAGE_RULE_HISTORY_TYPE = "rechazo_regla_automatica";
 const defaultFilters = () => ({
     itemMode: "all",
     itemIds: [],
@@ -56,6 +57,58 @@ const roundPercentage = (value, digits = 4) => {
     return Math.round((value + Number.EPSILON) * factor) / factor;
 };
 const clampPercentage = (value) => Math.min(100, Math.max(0, value));
+const toLayerNumber = (value) => {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+};
+const normalizeRejectionPercentageLayers = (layers) => ({
+    additive: clampPercentage(roundPercentage(toLayerNumber(layers?.additive))),
+    successive: Array.isArray(layers?.successive)
+        ? layers.successive.map((value) => toLayerNumber(value))
+        : [],
+});
+exports.normalizeRejectionPercentageLayers = normalizeRejectionPercentageLayers;
+const applyRejectionPercentageLayers = (layers, application) => {
+    const current = (0, exports.normalizeRejectionPercentageLayers)(layers);
+    const value = toLayerNumber(application.value);
+    switch (application.mode) {
+        case "add":
+            return {
+                additive: clampPercentage(roundPercentage(current.additive + value)),
+                successive: [...current.successive],
+            };
+        case "replace":
+            return {
+                additive: clampPercentage(roundPercentage(value)),
+                successive: [],
+            };
+        case "successive":
+            return {
+                additive: current.additive,
+                successive: [...current.successive, value],
+            };
+        default: {
+            const _exhaustive = application.mode;
+            return _exhaustive;
+        }
+    }
+};
+exports.applyRejectionPercentageLayers = applyRejectionPercentageLayers;
+/**
+ * Effective rejection % after additive then each successive rate on the remainder.
+ * 10% then 10% successive → 19, not 20.
+ */
+const computeEffectiveRejectionPercentage = (layers, digits = 2) => {
+    const normalized = (0, exports.normalizeRejectionPercentageLayers)(layers);
+    let remainingFactor = 1 - normalized.additive / 100;
+    for (const rate of normalized.successive) {
+        remainingFactor *= 1 - rate / 100;
+    }
+    return roundPercentage((1 - remainingFactor) * 100, digits);
+};
+exports.computeEffectiveRejectionPercentage = computeEffectiveRejectionPercentage;
+const hasSuccessiveRejectionLayers = (layers) => Array.isArray(layers?.successive) && layers.successive.length > 0;
+exports.hasSuccessiveRejectionLayers = hasSuccessiveRejectionLayers;
 const formatPercentage = (value) => Number.isInteger(value) ? String(value) : String(roundPercentage(value));
 const formatFinalPercentage = (value) => roundPercentage(value, 2).toFixed(2);
 const formatRuleEffect = (step) => {
@@ -91,6 +144,27 @@ const resolveRejectionPercentageOrigin = (passedPercentage, previousCalculations
     return clampPercentage(safePreviousBase + (passed - previousFinal));
 };
 exports.resolveRejectionPercentageOrigin = resolveRejectionPercentageOrigin;
+const rejectionRuleStepKey = (step) => `${step.ruleName}|${step.operation}|${step.value}`;
+exports.rejectionRuleStepKey = rejectionRuleStepKey;
+/**
+ * Rules already stored in the memo are skipped so a later edit does not
+ * create a second history line (or a second +2%) for the same rule.
+ */
+const getNewlyAppliedRejectionRuleSteps = (previous, next) => {
+    if (!next?.steps?.length) {
+        return [];
+    }
+    const previousKeys = new Set((previous?.steps ?? []).map(exports.rejectionRuleStepKey));
+    return next.steps.filter((step) => !previousKeys.has((0, exports.rejectionRuleStepKey)(step)));
+};
+exports.getNewlyAppliedRejectionRuleSteps = getNewlyAppliedRejectionRuleSteps;
+const formatAutomaticRejectionRuleHistoryDescription = (step) => {
+    const sign = step.operation === "subtract" ? "-" : "+";
+    return `% Rechazo aplicado automáticamente por regla "${step.ruleName}": ${sign}${formatPercentage(step.value)}%.`;
+};
+exports.formatAutomaticRejectionRuleHistoryDescription = formatAutomaticRejectionRuleHistoryDescription;
+const isAutomaticRejectionRuleHistoryType = (type) => type === exports.REJECTION_PERCENTAGE_RULE_HISTORY_TYPE;
+exports.isAutomaticRejectionRuleHistoryType = isAutomaticRejectionRuleHistoryType;
 const applyRejectionPercentageAdjustmentRules = (basePercentage, rules, ctx) => {
     const start = Number(basePercentage);
     const safeBase = Number.isFinite(start) ? clampPercentage(start) : 0;

package/dist/rejectionPercentageAdjustment.d.ts

@@ -1,11 +1,28 @@
-import type { RejectionCalculationMemo, RejectionPercentageAdjustmentContext, RejectionPercentageAdjustmentResult, RejectionPercentageAdjustmentRule, WebAppRowGraphQL } from "@zauru-sdk/types";
+import type { RejectionCalculationMemo, RejectionPercentageAdjustmentContext, RejectionPercentageAdjustmentResult, RejectionPercentageAdjustmentRule, RejectionPercentageAdjustmentStep, RejectionPercentageApplication, RejectionPercentageLayers, WebAppRowGraphQL } from "@zauru-sdk/types";
 export declare const REJECTION_PERCENTAGE_ADJUSTMENT_RULES_TABLE_VAR = "rejection_percentage_adjustment_rules_web_app_table_id";
+export declare const REJECTION_PERCENTAGE_RULE_HISTORY_TYPE: "rechazo_regla_automatica";
 export declare const filterActiveRejectionPercentageAdjustmentRules: (rules?: WebAppRowGraphQL<RejectionPercentageAdjustmentRule>[]) => WebAppRowGraphQL<RejectionPercentageAdjustmentRule>[];
 export declare const rejectionPercentageAdjustmentRuleMatches: (rule: RejectionPercentageAdjustmentRule, ctx: RejectionPercentageAdjustmentContext) => boolean;
+export declare const normalizeRejectionPercentageLayers: (layers?: Partial<RejectionPercentageLayers> | null) => RejectionPercentageLayers;
+export declare const applyRejectionPercentageLayers: (layers: RejectionPercentageLayers, application: RejectionPercentageApplication) => RejectionPercentageLayers;
+/**
+ * Effective rejection % after additive then each successive rate on the remainder.
+ * 10% then 10% successive → 19, not 20.
+ */
+export declare const computeEffectiveRejectionPercentage: (layers: RejectionPercentageLayers, digits?: number) => number;
+export declare const hasSuccessiveRejectionLayers: (layers?: Partial<RejectionPercentageLayers> | null) => boolean;
 export declare const formatRejectionPercentageAdjustmentDescription: (result: Pick<RejectionPercentageAdjustmentResult, "basePercentage" | "finalPercentage" | "steps">, baseLabel?: string) => string;
 /**
  * Callers may pass the origin % or the previously stored final %. With the
  * previous calculations we go back to the origin so the rules never stack twice.
  */
 export declare const resolveRejectionPercentageOrigin: (passedPercentage: number, previousCalculations?: RejectionCalculationMemo | null) => number;
+export declare const rejectionRuleStepKey: (step: Pick<RejectionPercentageAdjustmentStep, "ruleName" | "operation" | "value">) => string;
+/**
+ * Rules already stored in the memo are skipped so a later edit does not
+ * create a second history line (or a second +2%) for the same rule.
+ */
+export declare const getNewlyAppliedRejectionRuleSteps: (previous?: RejectionCalculationMemo | null, next?: RejectionCalculationMemo | null) => RejectionPercentageAdjustmentStep[];
+export declare const formatAutomaticRejectionRuleHistoryDescription: (step: RejectionPercentageAdjustmentStep) => string;
+export declare const isAutomaticRejectionRuleHistoryType: (type: string | undefined) => boolean;
 export declare const applyRejectionPercentageAdjustmentRules: (basePercentage: number, rules: Array<RejectionPercentageAdjustmentRule | WebAppRowGraphQL<RejectionPercentageAdjustmentRule>>, ctx: RejectionPercentageAdjustmentContext) => RejectionPercentageAdjustmentResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/common",
-  "version": "6.6.0",
+  "version": "6.8.0",
   "description": "Funciones de uso común en el desarrollo de webapps en Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -21,9 +21,9 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/types": "^6.16.0",
+    "@zauru-sdk/types": "^6.18.0",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "9e840d01a540f2ab49233dda2cb2b0c916ffba0b"
+  "gitHead": "c5b785baa29fdd2ab7f42a9077ba5cbe5c7c9707"
 }

package/src/common.ts

@@ -10,10 +10,15 @@ import type {
   CalculatePurchaseOrderFinancialsInput,
   CalculatePurchaseOrderFinancialsResult,
   PurchaseOrderFinancialDetail,
+  RejectionPercentageLayers,
 } from "@zauru-sdk/types";
 import { MONTHS } from "@zauru-sdk/types";
 import {
   applyRejectionPercentageAdjustmentRules,
+  applyRejectionPercentageLayers,
+  computeEffectiveRejectionPercentage,
+  hasSuccessiveRejectionLayers,
+  normalizeRejectionPercentageLayers,
   resolveRejectionPercentageOrigin,
 } from "./rejectionPercentageAdjustment.js";
 
@@ -89,17 +94,58 @@ export const setRejectionPercentage = (
   percentage: number,
 ): string => mergeJsonMemo(memo, { rejectionPercentage: percentage });
 
+const memoFromRejectionSource = (
+  source: string | { memo?: string | object } | JsonMemoType | undefined,
+): JsonMemoType => {
+  if (source == null || source === "") return {};
+  if (typeof source === "string") return parseJsonMemo(source);
+  if (typeof source !== "object") return {};
+  const record = source as { memo?: string | object } & JsonMemoType;
+  if (record.memo != null && record.memo !== "") {
+    return parseJsonMemo(record.memo);
+  }
+  return parseJsonMemo(record);
+};
+
+/**
+ * User rejection layers (before automatic rules). Legacy memos without
+ * `rejectionLayers` use the stored origin as additive and no successive rates.
+ */
+export const resolveRejectionPercentageLayers = (
+  memo?: string | object | JsonMemoType,
+  fallbackAdditive?: number,
+): RejectionPercentageLayers => {
+  const parsed = parseJsonMemo(memo);
+  if (parsed.rejectionLayers) {
+    return normalizeRejectionPercentageLayers(parsed.rejectionLayers);
+  }
+
+  const origin = resolveRejectionPercentageOrigin(
+    fallbackAdditive ?? getRejectionPercentage(parsed),
+    parsed.rejectionCalculations,
+  );
+  return normalizeRejectionPercentageLayers({
+    additive: origin,
+    successive: [],
+  });
+};
+
+export const getRejectionPercentageLayers = (
+  source: string | { memo?: string | object } | JsonMemoType | undefined,
+): RejectionPercentageLayers =>
+  resolveRejectionPercentageLayers(memoFromRejectionSource(source));
+
+export const hasSuccessiveRejectionPercentage = (
+  source: string | { memo?: string | object } | JsonMemoType | undefined,
+): boolean => hasSuccessiveRejectionLayers(getRejectionPercentageLayers(source));
+
 /**
  * Rejection % of origin stored in the memo, ignoring the adjustment rules
  * already applied on top of it.
  */
 export const resolveRejectionPercentageBase = (
   memo?: string | object,
-): number =>
-  resolveRejectionPercentageOrigin(
-    getRejectionPercentage(memo),
-    parseJsonMemo(memo).rejectionCalculations,
-  );
+): number => resolveRejectionPercentageLayers(memo).additive;
 
 const roundMoney = (value: number): number =>
   Math.round((value + Number.EPSILON) * 100) / 100;
@@ -119,14 +165,13 @@ const lineQuantity = (detail: PurchaseOrderFinancialDetail): number => {
 };
 
 /**
- * Header money for a purchase order: subtotal = qty × unit_cost,
- * discount = subtotal × rejectionPercentage / 100.
+ * Header money for a purchase order: subtotal = qty × unit_cost.
+ * Additive rates are summed first; successive rates then apply to the remainder.
  * Does not change unit cost. purchase_orders.discount is the monetary column.
  *
- * If `rules` is given, the rejection % is resolved back to the origin stored in
- * the memo and the rules are stacked on top of it before calculating the money.
- * `rejectionPercentage` in the result is the % that was actually charged and
- * `rejectionCalculations` is the trace to store in the memo.
+ * User layers (before rules) are returned as `rejectionLayers` for the memo.
+ * Automatic rules add percentage points on the additive block only.
+ * `rejectionPercentage` in the result is the effective % that was charged.
  */
 export const calculatePurchaseOrderFinancials = (
   input: CalculatePurchaseOrderFinancialsInput,
@@ -140,28 +185,45 @@ export const calculatePurchaseOrderFinancials = (
   );
   const safeSubtotal = Number.isFinite(subtotal) ? subtotal : 0;
 
-  const passedPercentage = toFiniteNumber(input.rejectionPercentage) ?? 0;
+  const parsedMemo = parseJsonMemo(input.memo);
+  let userLayers = input.rejectionLayers
+    ? normalizeRejectionPercentageLayers(input.rejectionLayers)
+    : resolveRejectionPercentageLayers(
+        parsedMemo,
+        toFiniteNumber(input.rejectionPercentage),
+      );
+
+  if (input.rejectionApplication) {
+    userLayers = applyRejectionPercentageLayers(
+      userLayers,
+      input.rejectionApplication,
+    );
+  }
+
   const rejectionCalculations = input.rules
     ? applyRejectionPercentageAdjustmentRules(
-        resolveRejectionPercentageOrigin(
-          passedPercentage,
-          parseJsonMemo(input.memo).rejectionCalculations,
-        ),
+        userLayers.additive,
         input.rules,
         input.ctx ?? { itemIds: [] },
       )
     : undefined;
 
+  const chargedLayers = {
+    additive:
+      rejectionCalculations?.finalPercentage ?? userLayers.additive,
+    successive: userLayers.successive,
+  };
   const rejectionPercentage =
-    rejectionCalculations?.finalPercentage ?? passedPercentage;
+    computeEffectiveRejectionPercentage(chargedLayers);
 
   return {
     subtotal: safeSubtotal,
     discount:
-      rejectionPercentage > 0 && safeSubtotal > 0
+      rejectionPercentage !== 0 && safeSubtotal > 0
         ? roundMoney(safeSubtotal * (rejectionPercentage / 100))
         : 0,
     rejectionPercentage,
+    rejectionLayers: userLayers,
     rejectionCalculations,
   };
 };

package/src/rejectionPercentageAdjustment.ts

@@ -6,12 +6,17 @@ import type {
   RejectionPercentageAdjustmentResult,
   RejectionPercentageAdjustmentRule,
   RejectionPercentageAdjustmentStep,
+  RejectionPercentageApplication,
+  RejectionPercentageLayers,
   WebAppRowGraphQL,
 } from "@zauru-sdk/types";
 
 export const REJECTION_PERCENTAGE_ADJUSTMENT_RULES_TABLE_VAR =
   "rejection_percentage_adjustment_rules_web_app_table_id";
 
+export const REJECTION_PERCENTAGE_RULE_HISTORY_TYPE =
+  "rechazo_regla_automatica" as const;
+
 const defaultFilters = (): PriceAdjustmentFilters => ({
   itemMode: "all",
   itemIds: [],
@@ -108,6 +113,71 @@ const roundPercentage = (value: number, digits = 4) => {
 
 const clampPercentage = (value: number) => Math.min(100, Math.max(0, value));
 
+const toLayerNumber = (value: unknown): number => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+
+export const normalizeRejectionPercentageLayers = (
+  layers?: Partial<RejectionPercentageLayers> | null,
+): RejectionPercentageLayers => ({
+  additive: clampPercentage(roundPercentage(toLayerNumber(layers?.additive))),
+  successive: Array.isArray(layers?.successive)
+    ? layers.successive.map((value) => toLayerNumber(value))
+    : [],
+});
+
+export const applyRejectionPercentageLayers = (
+  layers: RejectionPercentageLayers,
+  application: RejectionPercentageApplication,
+): RejectionPercentageLayers => {
+  const current = normalizeRejectionPercentageLayers(layers);
+  const value = toLayerNumber(application.value);
+
+  switch (application.mode) {
+    case "add":
+      return {
+        additive: clampPercentage(roundPercentage(current.additive + value)),
+        successive: [...current.successive],
+      };
+    case "replace":
+      return {
+        additive: clampPercentage(roundPercentage(value)),
+        successive: [],
+      };
+    case "successive":
+      return {
+        additive: current.additive,
+        successive: [...current.successive, value],
+      };
+    default: {
+      const _exhaustive: never = application.mode;
+      return _exhaustive;
+    }
+  }
+};
+
+/**
+ * Effective rejection % after additive then each successive rate on the remainder.
+ * 10% then 10% successive → 19, not 20.
+ */
+export const computeEffectiveRejectionPercentage = (
+  layers: RejectionPercentageLayers,
+  digits = 2,
+): number => {
+  const normalized = normalizeRejectionPercentageLayers(layers);
+  let remainingFactor = 1 - normalized.additive / 100;
+  for (const rate of normalized.successive) {
+    remainingFactor *= 1 - rate / 100;
+  }
+  return roundPercentage((1 - remainingFactor) * 100, digits);
+};
+
+export const hasSuccessiveRejectionLayers = (
+  layers?: Partial<RejectionPercentageLayers> | null,
+): boolean =>
+  Array.isArray(layers?.successive) && layers.successive.length > 0;
+
 const formatPercentage = (value: number) =>
   Number.isInteger(value) ? String(value) : String(roundPercentage(value));
 
@@ -162,6 +232,43 @@ export const resolveRejectionPercentageOrigin = (
   return clampPercentage(safePreviousBase + (passed - previousFinal));
 };
 
+export const rejectionRuleStepKey = (
+  step: Pick<
+    RejectionPercentageAdjustmentStep,
+    "ruleName" | "operation" | "value"
+  >,
+): string => `${step.ruleName}|${step.operation}|${step.value}`;
+
+/**
+ * Rules already stored in the memo are skipped so a later edit does not
+ * create a second history line (or a second +2%) for the same rule.
+ */
+export const getNewlyAppliedRejectionRuleSteps = (
+  previous?: RejectionCalculationMemo | null,
+  next?: RejectionCalculationMemo | null,
+): RejectionPercentageAdjustmentStep[] => {
+  if (!next?.steps?.length) {
+    return [];
+  }
+  const previousKeys = new Set(
+    (previous?.steps ?? []).map(rejectionRuleStepKey),
+  );
+  return next.steps.filter(
+    (step) => !previousKeys.has(rejectionRuleStepKey(step)),
+  );
+};
+
+export const formatAutomaticRejectionRuleHistoryDescription = (
+  step: RejectionPercentageAdjustmentStep,
+): string => {
+  const sign = step.operation === "subtract" ? "-" : "+";
+  return `% Rechazo aplicado automáticamente por regla "${step.ruleName}": ${sign}${formatPercentage(step.value)}%.`;
+};
+
+export const isAutomaticRejectionRuleHistoryType = (
+  type: string | undefined,
+): boolean => type === REJECTION_PERCENTAGE_RULE_HISTORY_TYPE;
+
 export const applyRejectionPercentageAdjustmentRules = (
   basePercentage: number,
   rules: Array<