@zauru-sdk/common 6.11.1 → 6.12.0

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [6.12.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.10.1...@zauru-sdk/common@6.12.0) (2026-10-26)
+
+
+### Bug Fixes
+
+* rechazar restricciones que dejan al proveedor sin opciones ([24e6609](https://github.com/intuitiva/zauru-typescript-sdk/commit/24e6609b9cbf1498bec52bbeae9cd52a57945b45))
+
+
+### Features
+
+* agregar matriz de restricciones de recepción ([11a07b0](https://github.com/intuitiva/zauru-typescript-sdk/commit/11a07b04aa71dd6a38b79f10c4209d08e8f7607c))
+* motor de restricciones de tipos y verduras por proveedor ([ea09fd6](https://github.com/intuitiva/zauru-typescript-sdk/commit/ea09fd6a4cbed61fc29640baf1bc2b0b78db18da))
+
+
+
+
+
 # [6.11.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.10.1...@zauru-sdk/common@6.11.0) (2026-10-23)
 
 

package/dist/esm/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./gtZones.js"), exports);
 __exportStar(require("./httpClientPolicy.js"), exports);
 __exportStar(require("./oauthErrors.js"), exports);
 __exportStar(require("./providerRestrictions.js"), exports);
+__exportStar(require("./providerReceptionMatrix.js"), exports);
 __exportStar(require("./rejectionPercentageAdjustment.js"), exports);

package/dist/esm/providerReceptionMatrix.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateProviderReceptionMatrix = exports.validateProviderReceptionException = exports.providerReceptionMatrixLeavesNoAllowedCombination = exports.resolveAllowedProviderReceptionTypes = exports.resolveAllowedProviderReceptionItems = exports.PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = exports.PROVIDER_RECEPTION_MATRIX_TABLE_VAR = void 0;
+const providerRestrictions_js_1 = require("./providerRestrictions.js");
+exports.PROVIDER_RECEPTION_MATRIX_TABLE_VAR = "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+exports.PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const isActive = (row, date) => {
+    if ((0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion) || !DATE_RE.test(date)) {
+        return false;
+    }
+    const start = (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.start_date);
+    const end = (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.end_date);
+    return DATE_RE.test(start) && DATE_RE.test(end) && start <= date && date <= end;
+};
+const matchesProviderAndType = (row, payeeId, receptionTypeCode) => Number(row.payee_id) === Number(payeeId) &&
+    (0, providerRestrictions_js_1.normalizeRestrictionValue)(row.reception_type_code) ===
+        (0, providerRestrictions_js_1.normalizeRestrictionValue)(receptionTypeCode);
+const resolveAllowedProviderReceptionItems = (input) => {
+    const universe = input.universe
+        .map(providerRestrictions_js_1.normalizeRestrictionValue)
+        .filter(Boolean);
+    const universeSet = new Set(universe);
+    const blocked = new Set((input.blockRules ?? [])
+        .filter((row) => !(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion) &&
+        matchesProviderAndType(row, input.payeeId, input.receptionTypeCode))
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.blocked_item_ids)));
+    const activeExceptions = (input.exceptions ?? []).filter((row) => matchesProviderAndType(row, input.payeeId, input.receptionTypeCode) && isActive(row, input.date));
+    const temporarilyAllowed = new Set(activeExceptions
+        .filter((row) => row.mode === "allow")
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids)));
+    const temporarilyBlocked = new Set(activeExceptions
+        .filter((row) => row.mode === "block")
+        .flatMap((row) => (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids)));
+    const allowed = new Set(universe.filter((itemId) => !blocked.has(itemId)));
+    for (const itemId of temporarilyAllowed) {
+        if (universeSet.has(itemId)) {
+            allowed.add(itemId);
+        }
+    }
+    for (const itemId of temporarilyBlocked) {
+        allowed.delete(itemId);
+    }
+    return universe.filter((itemId) => allowed.has(itemId));
+};
+exports.resolveAllowedProviderReceptionItems = resolveAllowedProviderReceptionItems;
+const resolveAllowedProviderReceptionTypes = (input) => input.receptionTypeCodes
+    .map(providerRestrictions_js_1.normalizeRestrictionValue)
+    .filter(Boolean)
+    .filter((receptionTypeCode) => (0, exports.resolveAllowedProviderReceptionItems)({
+    ...input,
+    receptionTypeCode,
+    universe: input.itemIds,
+}).length > 0);
+exports.resolveAllowedProviderReceptionTypes = resolveAllowedProviderReceptionTypes;
+const providerReceptionMatrixLeavesNoAllowedCombination = (input) => {
+    const relevantExceptions = (input.exceptions ?? []).filter((row) => Number(row.payee_id) === Number(input.payeeId) &&
+        !(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.fechaEliminacion));
+    const dates = (0, providerRestrictions_js_1.sampleDatesForRestrictionRules)(relevantExceptions);
+    return dates.some((date) => (0, exports.resolveAllowedProviderReceptionTypes)({
+        ...input,
+        date,
+    }).length === 0);
+};
+exports.providerReceptionMatrixLeavesNoAllowedCombination = providerReceptionMatrixLeavesNoAllowedCombination;
+const validateProviderReceptionException = (row, options) => {
+    const errors = [];
+    const typeCodes = new Set(options.receptionTypeCodes.map(providerRestrictions_js_1.normalizeRestrictionValue).filter(Boolean));
+    const itemIds = new Set(options.itemIds.map(providerRestrictions_js_1.normalizeRestrictionValue).filter(Boolean));
+    const selectedItems = (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids);
+    if (!Number(row.payee_id) || Number(row.payee_id) < 1) {
+        errors.push("Seleccione un proveedor.");
+    }
+    if (!typeCodes.has((0, providerRestrictions_js_1.normalizeRestrictionValue)(row.reception_type_code))) {
+        errors.push("Seleccione un tipo de recepción válido.");
+    }
+    if (row.mode !== "allow" && row.mode !== "block") {
+        errors.push("Seleccione si la excepción permite o bloquea verduras.");
+    }
+    if (selectedItems.length === 0 ||
+        selectedItems.some((itemId) => !itemIds.has(itemId))) {
+        errors.push("Seleccione al menos una verdura válida.");
+    }
+    if (!DATE_RE.test(row.start_date) ||
+        !DATE_RE.test(row.end_date) ||
+        row.start_date > row.end_date) {
+        errors.push("Indique un rango de fechas válido.");
+    }
+    if (!(0, providerRestrictions_js_1.normalizeRestrictionValue)(row.motivo)) {
+        errors.push("Indique el motivo de la excepción.");
+    }
+    return errors;
+};
+exports.validateProviderReceptionException = validateProviderReceptionException;
+const evaluateProviderReceptionMatrix = (input) => {
+    const itemId = (0, providerRestrictions_js_1.normalizeRestrictionValue)(input.itemId);
+    const allowed = (0, exports.resolveAllowedProviderReceptionItems)({
+        ...input,
+        universe: input.itemIds,
+    });
+    if (allowed.includes(itemId)) {
+        return { allowed: true };
+    }
+    const blockingException = (input.exceptions ?? []).find((row) => row.mode === "block" &&
+        matchesProviderAndType(row, input.payeeId, input.receptionTypeCode) &&
+        isActive(row, input.date) &&
+        (0, providerRestrictions_js_1.normalizeProviderRestrictionValues)(row.item_ids).includes(itemId));
+    const itemLabel = (0, providerRestrictions_js_1.normalizeRestrictionValue)(input.itemLabel) || itemId;
+    if (blockingException) {
+        return {
+            allowed: false,
+            mode: "exclude",
+            matchedValues: [itemLabel],
+            title: "Verdura no permitida para este proveedor",
+            description: `Del ${blockingException.start_date} al ${blockingException.end_date}, la verdura "${itemLabel}" está bloqueada para el tipo ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(input.receptionTypeCode)}. Motivo: ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(blockingException.motivo)}.`,
+        };
+    }
+    return {
+        allowed: false,
+        mode: "exclude",
+        matchedValues: [itemLabel],
+        title: "Verdura no permitida para este proveedor",
+        description: `La combinación de tipo ${(0, providerRestrictions_js_1.normalizeRestrictionValue)(input.receptionTypeCode)} y verdura "${itemLabel}" está desmarcada en la matriz del proveedor.`,
+    };
+};
+exports.evaluateProviderReceptionMatrix = evaluateProviderReceptionMatrix;

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from "./gtZones.js";
 export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
+export * from "./providerReceptionMatrix.js";
 export * from "./rejectionPercentageAdjustment.js";

package/dist/providerReceptionMatrix.d.ts

@@ -0,0 +1,40 @@
+import type { ProviderReceptionBlockRule, ProviderReceptionException, ProviderRestrictionCheckResult } from "@zauru-sdk/types";
+export declare const PROVIDER_RECEPTION_MATRIX_TABLE_VAR = "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+export declare const PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR = "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+export declare const resolveAllowedProviderReceptionItems: (input: {
+    payeeId: number;
+    receptionTypeCode: string;
+    date: string;
+    universe: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => string[];
+export declare const resolveAllowedProviderReceptionTypes: (input: {
+    payeeId: number;
+    date: string;
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => string[];
+export declare const providerReceptionMatrixLeavesNoAllowedCombination: (input: {
+    payeeId: number;
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => boolean;
+export declare const validateProviderReceptionException: (row: ProviderReceptionException, options: {
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+}) => string[];
+export declare const evaluateProviderReceptionMatrix: (input: {
+    payeeId: number;
+    receptionTypeCode: string;
+    date: string;
+    itemId: string | number;
+    itemLabel?: string;
+    itemIds: Array<string | number>;
+    blockRules?: ProviderReceptionBlockRule[];
+    exceptions?: ProviderReceptionException[];
+}) => ProviderRestrictionCheckResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/common",
-  "version": "6.11.1",
+  "version": "6.12.0",
   "description": "Funciones de uso común en el desarrollo de webapps en Zauru",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -12,7 +12,7 @@
   "scripts": {
     "build": "npm run build:esm",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts"
+    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts src/providerReceptionMatrix.test.ts"
   },
   "author": "Oscar Cuéllar",
   "license": "MIT",
@@ -22,9 +22,9 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/types": "^6.27.0",
+    "@zauru-sdk/types": "^6.28.0",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "04f79cf77f767191f4be6358d9b23a3a0f1641b0"
+  "gitHead": "2fda4a18e3f62d22c38fbb91052869db9ebc16f4"
 }

package/src/index.ts

@@ -3,4 +3,5 @@ export * from "./gtZones.js";
 export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
+export * from "./providerReceptionMatrix.js";
 export * from "./rejectionPercentageAdjustment.js";

package/src/providerReceptionMatrix.test.ts

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+  ProviderReceptionBlockRule,
+  ProviderReceptionException,
+} from "@zauru-sdk/types";
+import {
+  evaluateProviderReceptionMatrix,
+  providerReceptionMatrixLeavesNoAllowedCombination,
+  resolveAllowedProviderReceptionItems,
+  resolveAllowedProviderReceptionTypes,
+  validateProviderReceptionException,
+} from "./providerReceptionMatrix.js";
+
+const block = (
+  partial: Partial<ProviderReceptionBlockRule> = {},
+): ProviderReceptionBlockRule => ({
+  payee_id: 10,
+  reception_type_code: "1",
+  blocked_item_ids: [],
+  ...partial,
+});
+
+const exception = (
+  partial: Partial<ProviderReceptionException> = {},
+): ProviderReceptionException => ({
+  payee_id: 10,
+  reception_type_code: "1",
+  mode: "block",
+  item_ids: [100],
+  start_date: "2026-10-01",
+  end_date: "2026-10-31",
+  motivo: "Suspensión temporal",
+  ...partial,
+});
+
+describe("resolveAllowedProviderReceptionItems", () => {
+  it("allows the whole universe when no matrix row exists", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+      }),
+      ["100", "200"],
+    );
+  });
+
+  it("blocks only the exact provider, type and item combination", () => {
+    const rules = [block({ blocked_item_ids: [100] })];
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: rules,
+      }),
+      ["200"],
+    );
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "Normal",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: rules,
+      }),
+      ["100", "200"],
+    );
+  });
+
+  it("allows a base-blocked item only inside an allow exception range", () => {
+    const input = {
+      payeeId: 10,
+      receptionTypeCode: "1",
+      universe: [100, 200],
+      blockRules: [block({ blocked_item_ids: [100] })],
+      exceptions: [exception({ mode: "allow" as const })],
+    };
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({ ...input, date: "2026-10-15" }),
+      ["100", "200"],
+    );
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({ ...input, date: "2026-11-01" }),
+      ["200"],
+    );
+  });
+
+  it("makes a temporary block win over an overlapping allow", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        exceptions: [
+          exception({ mode: "allow" }),
+          exception({ mode: "block" }),
+        ],
+      }),
+      ["200"],
+    );
+  });
+
+  it("ignores soft-deleted matrix rows and exceptions", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionItems({
+        payeeId: 10,
+        receptionTypeCode: "1",
+        date: "2026-10-15",
+        universe: [100, 200],
+        blockRules: [
+          block({ blocked_item_ids: [100], fechaEliminacion: "2026-10-01" }),
+        ],
+        exceptions: [exception({ fechaEliminacion: "2026-10-01" })],
+      }),
+      ["100", "200"],
+    );
+  });
+});
+
+describe("provider reception matrix validation", () => {
+  it("keeps only reception types with at least one allowed item", () => {
+    assert.deepEqual(
+      resolveAllowedProviderReceptionTypes({
+        payeeId: 10,
+        date: "2026-10-15",
+        receptionTypeCodes: ["Normal", "1"],
+        itemIds: [100],
+        blockRules: [block({ blocked_item_ids: [100] })],
+      }),
+      ["Normal"],
+    );
+  });
+
+  it("rejects rules whose dated overlap leaves no valid combination", () => {
+    assert.equal(
+      providerReceptionMatrixLeavesNoAllowedCombination({
+        payeeId: 10,
+        receptionTypeCodes: ["Normal", "1"],
+        itemIds: [100],
+        blockRules: [block({ blocked_item_ids: [100] })],
+        exceptions: [
+          exception({
+            reception_type_code: "Normal",
+            mode: "block",
+            item_ids: [100],
+          }),
+        ],
+      }),
+      true,
+    );
+  });
+
+  it("requires valid dates, items and motivo for exceptions", () => {
+    const errors = validateProviderReceptionException(
+      exception({ end_date: "2026-09-01", motivo: "", item_ids: [999] }),
+      { receptionTypeCodes: ["1"], itemIds: [100, 200] },
+    );
+    assert.equal(errors.length, 3);
+  });
+});
+
+describe("evaluateProviderReceptionMatrix", () => {
+  it("includes the temporary reason and inclusive range when blocked", () => {
+    const result = evaluateProviderReceptionMatrix({
+      payeeId: 10,
+      receptionTypeCode: "1",
+      date: "2026-10-31",
+      itemId: 100,
+      itemLabel: "Ejote",
+      itemIds: [100, 200],
+      exceptions: [exception()],
+    });
+    assert.equal(result.allowed, false);
+    if (!result.allowed) {
+      assert.match(result.description, /Suspensión temporal/);
+      assert.match(result.description, /2026-10-31/);
+    }
+  });
+});

package/src/providerReceptionMatrix.ts

@@ -0,0 +1,237 @@
+import type {
+  ProviderReceptionBlockRule,
+  ProviderReceptionException,
+  ProviderRestrictionCheckResult,
+} from "@zauru-sdk/types";
+import {
+  normalizeProviderRestrictionValues,
+  normalizeRestrictionValue,
+  sampleDatesForRestrictionRules,
+} from "./providerRestrictions.js";
+
+export const PROVIDER_RECEPTION_MATRIX_TABLE_VAR =
+  "ctl_calidad_admin_matriz_recepcion_proveedor_web_app_table_id";
+
+export const PROVIDER_RECEPTION_EXCEPTIONS_TABLE_VAR =
+  "ctl_calidad_admin_excepciones_recepcion_proveedor_web_app_table_id";
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+const isActive = (
+  row: Pick<ProviderReceptionException, "start_date" | "end_date" | "fechaEliminacion">,
+  date: string,
+): boolean => {
+  if (normalizeRestrictionValue(row.fechaEliminacion) || !DATE_RE.test(date)) {
+    return false;
+  }
+  const start = normalizeRestrictionValue(row.start_date);
+  const end = normalizeRestrictionValue(row.end_date);
+  return DATE_RE.test(start) && DATE_RE.test(end) && start <= date && date <= end;
+};
+
+const matchesProviderAndType = (
+  row: { payee_id: number; reception_type_code: string },
+  payeeId: number,
+  receptionTypeCode: string,
+): boolean =>
+  Number(row.payee_id) === Number(payeeId) &&
+  normalizeRestrictionValue(row.reception_type_code) ===
+    normalizeRestrictionValue(receptionTypeCode);
+
+export const resolveAllowedProviderReceptionItems = (input: {
+  payeeId: number;
+  receptionTypeCode: string;
+  date: string;
+  universe: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): string[] => {
+  const universe = input.universe
+    .map(normalizeRestrictionValue)
+    .filter(Boolean);
+  const universeSet = new Set(universe);
+  const blocked = new Set(
+    (input.blockRules ?? [])
+      .filter(
+        (row) =>
+          !normalizeRestrictionValue(row.fechaEliminacion) &&
+          matchesProviderAndType(
+            row,
+            input.payeeId,
+            input.receptionTypeCode,
+          ),
+      )
+      .flatMap((row) =>
+        normalizeProviderRestrictionValues(row.blocked_item_ids),
+      ),
+  );
+
+  const activeExceptions = (input.exceptions ?? []).filter(
+    (row) =>
+      matchesProviderAndType(
+        row,
+        input.payeeId,
+        input.receptionTypeCode,
+      ) && isActive(row, input.date),
+  );
+
+  const temporarilyAllowed = new Set(
+    activeExceptions
+      .filter((row) => row.mode === "allow")
+      .flatMap((row) => normalizeProviderRestrictionValues(row.item_ids)),
+  );
+  const temporarilyBlocked = new Set(
+    activeExceptions
+      .filter((row) => row.mode === "block")
+      .flatMap((row) => normalizeProviderRestrictionValues(row.item_ids)),
+  );
+
+  const allowed = new Set(universe.filter((itemId) => !blocked.has(itemId)));
+  for (const itemId of temporarilyAllowed) {
+    if (universeSet.has(itemId)) {
+      allowed.add(itemId);
+    }
+  }
+  for (const itemId of temporarilyBlocked) {
+    allowed.delete(itemId);
+  }
+
+  return universe.filter((itemId) => allowed.has(itemId));
+};
+
+export const resolveAllowedProviderReceptionTypes = (input: {
+  payeeId: number;
+  date: string;
+  receptionTypeCodes: Array<string | number>;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): string[] =>
+  input.receptionTypeCodes
+    .map(normalizeRestrictionValue)
+    .filter(Boolean)
+    .filter(
+      (receptionTypeCode) =>
+        resolveAllowedProviderReceptionItems({
+          ...input,
+          receptionTypeCode,
+          universe: input.itemIds,
+        }).length > 0,
+    );
+
+export const providerReceptionMatrixLeavesNoAllowedCombination = (input: {
+  payeeId: number;
+  receptionTypeCodes: Array<string | number>;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): boolean => {
+  const relevantExceptions = (input.exceptions ?? []).filter(
+    (row) =>
+      Number(row.payee_id) === Number(input.payeeId) &&
+      !normalizeRestrictionValue(row.fechaEliminacion),
+  );
+  const dates = sampleDatesForRestrictionRules(relevantExceptions);
+  return dates.some(
+    (date) =>
+      resolveAllowedProviderReceptionTypes({
+        ...input,
+        date,
+      }).length === 0,
+  );
+};
+
+export const validateProviderReceptionException = (
+  row: ProviderReceptionException,
+  options: {
+    receptionTypeCodes: Array<string | number>;
+    itemIds: Array<string | number>;
+  },
+): string[] => {
+  const errors: string[] = [];
+  const typeCodes = new Set(
+    options.receptionTypeCodes.map(normalizeRestrictionValue).filter(Boolean),
+  );
+  const itemIds = new Set(
+    options.itemIds.map(normalizeRestrictionValue).filter(Boolean),
+  );
+  const selectedItems = normalizeProviderRestrictionValues(row.item_ids);
+
+  if (!Number(row.payee_id) || Number(row.payee_id) < 1) {
+    errors.push("Seleccione un proveedor.");
+  }
+  if (!typeCodes.has(normalizeRestrictionValue(row.reception_type_code))) {
+    errors.push("Seleccione un tipo de recepción válido.");
+  }
+  if (row.mode !== "allow" && row.mode !== "block") {
+    errors.push("Seleccione si la excepción permite o bloquea verduras.");
+  }
+  if (
+    selectedItems.length === 0 ||
+    selectedItems.some((itemId) => !itemIds.has(itemId))
+  ) {
+    errors.push("Seleccione al menos una verdura válida.");
+  }
+  if (
+    !DATE_RE.test(row.start_date) ||
+    !DATE_RE.test(row.end_date) ||
+    row.start_date > row.end_date
+  ) {
+    errors.push("Indique un rango de fechas válido.");
+  }
+  if (!normalizeRestrictionValue(row.motivo)) {
+    errors.push("Indique el motivo de la excepción.");
+  }
+  return errors;
+};
+
+export const evaluateProviderReceptionMatrix = (input: {
+  payeeId: number;
+  receptionTypeCode: string;
+  date: string;
+  itemId: string | number;
+  itemLabel?: string;
+  itemIds: Array<string | number>;
+  blockRules?: ProviderReceptionBlockRule[];
+  exceptions?: ProviderReceptionException[];
+}): ProviderRestrictionCheckResult => {
+  const itemId = normalizeRestrictionValue(input.itemId);
+  const allowed = resolveAllowedProviderReceptionItems({
+    ...input,
+    universe: input.itemIds,
+  });
+  if (allowed.includes(itemId)) {
+    return { allowed: true };
+  }
+
+  const blockingException = (input.exceptions ?? []).find(
+    (row) =>
+      row.mode === "block" &&
+      matchesProviderAndType(
+        row,
+        input.payeeId,
+        input.receptionTypeCode,
+      ) &&
+      isActive(row, input.date) &&
+      normalizeProviderRestrictionValues(row.item_ids).includes(itemId),
+  );
+  const itemLabel = normalizeRestrictionValue(input.itemLabel) || itemId;
+
+  if (blockingException) {
+    return {
+      allowed: false,
+      mode: "exclude",
+      matchedValues: [itemLabel],
+      title: "Verdura no permitida para este proveedor",
+      description: `Del ${blockingException.start_date} al ${blockingException.end_date}, la verdura "${itemLabel}" está bloqueada para el tipo ${normalizeRestrictionValue(input.receptionTypeCode)}. Motivo: ${normalizeRestrictionValue(blockingException.motivo)}.`,
+    };
+  }
+
+  return {
+    allowed: false,
+    mode: "exclude",
+    matchedValues: [itemLabel],
+    title: "Verdura no permitida para este proveedor",
+    description: `La combinación de tipo ${normalizeRestrictionValue(input.receptionTypeCode)} y verdura "${itemLabel}" está desmarcada en la matriz del proveedor.`,
+  };
+};