@zauru-sdk/common 6.10.1 → 6.11.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [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)
+
+
+### Features
+
+* motor de restricciones de tipos y verduras por proveedor ([ea09fd6](https://github.com/intuitiva/zauru-typescript-sdk/commit/ea09fd6a4cbed61fc29640baf1bc2b0b78db18da))
+
+
+
+
+
 ## [6.10.1](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.10.0...@zauru-sdk/common@6.10.1) (2026-10-23)
 
 **Note:** Version bump only for package @zauru-sdk/common

package/dist/esm/index.js

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

package/dist/esm/providerRestrictions.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkProviderRestrictionValue = exports.validateProviderRestrictionInput = exports.matchReceptionTypeCode = exports.isRestrictionValueAllowed = exports.resolveAllowedRestrictionValues = exports.filterActiveProviderRestrictions = exports.isRestrictionActiveOnDate = exports.restrictionHasDateRange = exports.normalizeProviderRestrictionValues = exports.isProviderRestrictionMode = exports.formatRestrictionTypeValue = exports.normalizeRestrictionValue = exports.PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = exports.PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = void 0;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+exports.PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_tipos_proveedor_web_app_table_id";
+exports.PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_verduras_proveedor_web_app_table_id";
+const normalizeRestrictionValue = (value) => String(value ?? "").replace(/\s+/g, " ").trim();
+exports.normalizeRestrictionValue = normalizeRestrictionValue;
+const formatRestrictionTypeValue = (type) => [type?.Nombre, type?.Codigo]
+    .map((part) => String(part ?? "").trim())
+    .filter(Boolean)
+    .join(" ");
+exports.formatRestrictionTypeValue = formatRestrictionTypeValue;
+const assertNever = (value) => {
+    throw new Error(`Unexpected restriction mode: ${String(value)}`);
+};
+const isProviderRestrictionMode = (value) => value === "include" || value === "exclude";
+exports.isProviderRestrictionMode = isProviderRestrictionMode;
+const normalizeProviderRestrictionValues = (values) => {
+    if (Array.isArray(values)) {
+        return values.map(exports.normalizeRestrictionValue).filter(Boolean);
+    }
+    if (typeof values === "string") {
+        const trimmed = values.trim();
+        if (!trimmed) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.map(exports.normalizeRestrictionValue).filter(Boolean);
+            }
+        }
+        catch {
+            return trimmed
+                .split(",")
+                .map((part) => (0, exports.normalizeRestrictionValue)(part))
+                .filter(Boolean);
+        }
+    }
+    return [];
+};
+exports.normalizeProviderRestrictionValues = normalizeProviderRestrictionValues;
+const restrictionHasDateRange = (rule) => Boolean((0, exports.normalizeRestrictionValue)(rule.start_date)) ||
+    Boolean((0, exports.normalizeRestrictionValue)(rule.end_date));
+exports.restrictionHasDateRange = restrictionHasDateRange;
+const isRestrictionActiveOnDate = (rule, date) => {
+    if ((0, exports.normalizeRestrictionValue)(rule.fechaEliminacion)) {
+        return false;
+    }
+    if (!(0, exports.isProviderRestrictionMode)(rule.mode)) {
+        return false;
+    }
+    const start = (0, exports.normalizeRestrictionValue)(rule.start_date);
+    const end = (0, exports.normalizeRestrictionValue)(rule.end_date);
+    if (!start && !end) {
+        return true;
+    }
+    if (!DATE_RE.test(date)) {
+        return false;
+    }
+    if (start && date < start) {
+        return false;
+    }
+    if (end && date > end) {
+        return false;
+    }
+    return true;
+};
+exports.isRestrictionActiveOnDate = isRestrictionActiveOnDate;
+const filterActiveProviderRestrictions = (rules, payeeId, date) => (rules ?? []).filter((rule) => Number(rule.payee_id) === Number(payeeId) &&
+    (0, exports.isRestrictionActiveOnDate)(rule, date));
+exports.filterActiveProviderRestrictions = filterActiveProviderRestrictions;
+const resolveAllowedRestrictionValues = (input) => {
+    const universe = input.universe
+        .map(exports.normalizeRestrictionValue)
+        .filter(Boolean);
+    const active = (0, exports.filterActiveProviderRestrictions)(input.rules, input.payeeId, input.date);
+    if (active.length === 0) {
+        return universe;
+    }
+    const includes = active.filter((rule) => rule.mode === "include");
+    const excludes = active.filter((rule) => rule.mode === "exclude");
+    let allowed = universe;
+    if (includes.length > 0) {
+        const union = new Set(includes.flatMap((rule) => (0, exports.normalizeProviderRestrictionValues)(rule.values)));
+        allowed = allowed.filter((value) => union.has(value));
+    }
+    if (excludes.length > 0) {
+        const blocked = new Set(excludes.flatMap((rule) => (0, exports.normalizeProviderRestrictionValues)(rule.values)));
+        allowed = allowed.filter((value) => !blocked.has(value));
+    }
+    return allowed;
+};
+exports.resolveAllowedRestrictionValues = resolveAllowedRestrictionValues;
+const isRestrictionValueAllowed = (input) => {
+    const allowed = (0, exports.resolveAllowedRestrictionValues)(input);
+    return allowed.includes((0, exports.normalizeRestrictionValue)(input.value));
+};
+exports.isRestrictionValueAllowed = isRestrictionValueAllowed;
+const matchReceptionTypeCode = (formValue, types) => {
+    const wanted = (0, exports.normalizeRestrictionValue)(formValue);
+    if (!wanted) {
+        return "";
+    }
+    for (const entry of types ?? []) {
+        const type = entry && typeof entry === "object" && "data" in entry
+            ? entry.data
+            : entry;
+        if (!type) {
+            continue;
+        }
+        const code = (0, exports.normalizeRestrictionValue)(type.Codigo);
+        const formatted = (0, exports.formatRestrictionTypeValue)(type);
+        if (wanted === code || wanted === formatted) {
+            return code || formatted;
+        }
+    }
+    return wanted;
+};
+exports.matchReceptionTypeCode = matchReceptionTypeCode;
+const validateProviderRestrictionInput = (input) => {
+    const errors = [];
+    if (!Number(input.payee_id) || Number(input.payee_id) < 1) {
+        errors.push({ field: "payee_id", message: "Seleccione un proveedor." });
+    }
+    if (!(0, exports.isProviderRestrictionMode)(input.mode)) {
+        errors.push({
+            field: "mode",
+            message: "Seleccione si se permiten o se bloquean esos valores.",
+        });
+    }
+    if ((0, exports.normalizeProviderRestrictionValues)(input.values).length === 0) {
+        errors.push({
+            field: "values",
+            message: "Seleccione al menos un valor.",
+        });
+    }
+    const start = (0, exports.normalizeRestrictionValue)(input.start_date);
+    const end = (0, exports.normalizeRestrictionValue)(input.end_date);
+    if (start || end) {
+        if (!start || !end) {
+            errors.push({
+                field: "start_date",
+                message: "Si usa fechas, indique inicio y fin.",
+            });
+        }
+        else {
+            if (!DATE_RE.test(start) || !DATE_RE.test(end)) {
+                errors.push({
+                    field: "start_date",
+                    message: "Las fechas deben ir en formato YYYY-MM-DD.",
+                });
+            }
+            else if (start > end) {
+                errors.push({
+                    field: "end_date",
+                    message: "La fecha fin no puede ser anterior a la fecha inicio.",
+                });
+            }
+        }
+        if (!(0, exports.normalizeRestrictionValue)(input.motivo)) {
+            errors.push({
+                field: "motivo",
+                message: "Indique el motivo de la excepción con rango de fechas.",
+            });
+        }
+    }
+    return errors;
+};
+exports.validateProviderRestrictionInput = validateProviderRestrictionInput;
+const describeMode = (mode) => {
+    switch (mode) {
+        case "include":
+            return "solo puede usar";
+        case "exclude":
+            return "no puede usar";
+        default:
+            return assertNever(mode);
+    }
+};
+const checkProviderRestrictionValue = (input) => {
+    const allowed = (0, exports.isRestrictionValueAllowed)(input);
+    if (allowed) {
+        return { allowed: true };
+    }
+    const active = (0, exports.filterActiveProviderRestrictions)(input.rules, input.payeeId, input.date);
+    const includes = active.filter((rule) => rule.mode === "include");
+    const mode = includes.length > 0 ? "include" : "exclude";
+    const valueLabel = (0, exports.normalizeRestrictionValue)(input.valueLabel) ||
+        (0, exports.normalizeRestrictionValue)(input.value);
+    return {
+        allowed: false,
+        mode,
+        matchedValues: [valueLabel],
+        title: `${input.label} no permitido para este proveedor`,
+        description: `En la fecha ${input.date} este proveedor ${describeMode(mode)} ${input.label.toLowerCase()} "${valueLabel}".`,
+    };
+};
+exports.checkProviderRestrictionValue = checkProviderRestrictionValue;

package/dist/index.d.ts

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

package/dist/providerRestrictions.d.ts

@@ -0,0 +1,51 @@
+import type { ProviderRestrictionCheckResult, ProviderRestrictionMode, ProviderRestrictionRule, ReceptionType } from "@zauru-sdk/types";
+export declare const PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_tipos_proveedor_web_app_table_id";
+export declare const PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR = "ctl_calidad_admin_restricciones_verduras_proveedor_web_app_table_id";
+export declare const normalizeRestrictionValue: (value: string | number | undefined | null) => string;
+export declare const formatRestrictionTypeValue: (type?: {
+    Nombre?: string;
+    Codigo?: string;
+} | null) => string;
+export declare const isProviderRestrictionMode: (value: unknown) => value is ProviderRestrictionMode;
+export declare const normalizeProviderRestrictionValues: (values: unknown) => string[];
+export declare const restrictionHasDateRange: (rule: Pick<ProviderRestrictionRule, "start_date" | "end_date">) => boolean;
+export declare const isRestrictionActiveOnDate: (rule: ProviderRestrictionRule, date: string) => boolean;
+export declare const filterActiveProviderRestrictions: (rules: ProviderRestrictionRule[] | undefined, payeeId: number, date: string) => ProviderRestrictionRule[];
+export declare const resolveAllowedRestrictionValues: (input: {
+    payeeId: number;
+    date: string;
+    rules: ProviderRestrictionRule[] | undefined;
+    universe: Array<string | number>;
+}) => string[];
+export declare const isRestrictionValueAllowed: (input: {
+    payeeId: number;
+    date: string;
+    value: string | number;
+    rules: ProviderRestrictionRule[] | undefined;
+    universe: Array<string | number>;
+}) => boolean;
+export declare const matchReceptionTypeCode: (formValue: string, types: Array<ReceptionType | {
+    data?: ReceptionType;
+}> | undefined) => string;
+export type ProviderRestrictionInput = {
+    payee_id: number;
+    mode: ProviderRestrictionMode | string;
+    values: unknown;
+    start_date?: string;
+    end_date?: string;
+    motivo?: string;
+};
+export type ProviderRestrictionInputError = {
+    field: string;
+    message: string;
+};
+export declare const validateProviderRestrictionInput: (input: ProviderRestrictionInput) => ProviderRestrictionInputError[];
+export declare const checkProviderRestrictionValue: (input: {
+    payeeId: number;
+    date: string;
+    value: string | number;
+    rules: ProviderRestrictionRule[] | undefined;
+    universe: Array<string | number>;
+    label: string;
+    valueLabel?: string;
+}) => ProviderRestrictionCheckResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/common",
-  "version": "6.10.1",
+  "version": "6.11.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"
+    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts"
   },
   "author": "Oscar Cuéllar",
   "license": "MIT",
@@ -22,9 +22,9 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/types": "^6.26.0",
+    "@zauru-sdk/types": "^6.27.0",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "868c8fc18ec36bd771fbd2b3886d15b6d68fb7bb"
+  "gitHead": "d8141f1d30edee6edb8d2777d0e12e2f4f1b2726"
 }

package/src/index.ts

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

package/src/providerRestrictions.test.ts

@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { ProviderRestrictionRule } from "@zauru-sdk/types";
+import {
+  checkProviderRestrictionValue,
+  filterActiveProviderRestrictions,
+  isRestrictionActiveOnDate,
+  isRestrictionValueAllowed,
+  matchReceptionTypeCode,
+  resolveAllowedRestrictionValues,
+  validateProviderRestrictionInput,
+} from "./providerRestrictions.js";
+
+const rule = (
+  partial: Partial<ProviderRestrictionRule> &
+    Pick<ProviderRestrictionRule, "payee_id" | "mode" | "values">,
+): ProviderRestrictionRule => ({
+  ...partial,
+});
+
+describe("isRestrictionActiveOnDate", () => {
+  it("When there is no date range, it should apply every day", () => {
+    assert.equal(
+      isRestrictionActiveOnDate(
+        rule({ payee_id: 1, mode: "exclude", values: ["A"] }),
+        "2026-10-27",
+      ),
+      true,
+    );
+  });
+
+  it("When the date is inside the range, it should apply on the boundaries", () => {
+    const dated = rule({
+      payee_id: 1,
+      mode: "exclude",
+      values: ["A"],
+      start_date: "2026-10-27",
+      end_date: "2026-11-02",
+    });
+    assert.equal(isRestrictionActiveOnDate(dated, "2026-10-27"), true);
+    assert.equal(isRestrictionActiveOnDate(dated, "2026-11-02"), true);
+    assert.equal(isRestrictionActiveOnDate(dated, "2026-10-26"), false);
+    assert.equal(isRestrictionActiveOnDate(dated, "2026-11-03"), false);
+  });
+
+  it("When the rule is soft-deleted, it should never apply", () => {
+    assert.equal(
+      isRestrictionActiveOnDate(
+        rule({
+          payee_id: 1,
+          mode: "exclude",
+          values: ["A"],
+          fechaEliminacion: "2026-10-01T00:00:00.000Z",
+        }),
+        "2026-10-27",
+      ),
+      false,
+    );
+  });
+});
+
+describe("resolveAllowedRestrictionValues", () => {
+  const universe = ["Normal", "Certificado 1", "Certificado 2"];
+
+  it("When there are no rules, it should allow the whole universe", () => {
+    assert.deepEqual(
+      resolveAllowedRestrictionValues({
+        payeeId: 10,
+        date: "2026-10-27",
+        rules: [],
+        universe,
+      }),
+      universe,
+    );
+  });
+
+  it("When an exclude rule is active, it should remove those codes", () => {
+    assert.deepEqual(
+      resolveAllowedRestrictionValues({
+        payeeId: 10,
+        date: "2026-10-28",
+        rules: [
+          rule({
+            payee_id: 10,
+            mode: "exclude",
+            values: ["Certificado 1", "Certificado 2"],
+            start_date: "2026-10-27",
+            end_date: "2026-11-02",
+          }),
+        ],
+        universe,
+      }),
+      ["Normal"],
+    );
+  });
+
+  it("When the date is outside the exclude range, it should allow everything", () => {
+    assert.deepEqual(
+      resolveAllowedRestrictionValues({
+        payeeId: 10,
+        date: "2026-11-10",
+        rules: [
+          rule({
+            payee_id: 10,
+            mode: "exclude",
+            values: ["Certificado 1"],
+            start_date: "2026-10-27",
+            end_date: "2026-11-02",
+          }),
+        ],
+        universe,
+      }),
+      universe,
+    );
+  });
+
+  it("When an include rule is active, it should keep only those values", () => {
+    assert.deepEqual(
+      resolveAllowedRestrictionValues({
+        payeeId: 10,
+        date: "2026-10-28",
+        rules: [
+          rule({
+            payee_id: 10,
+            mode: "include",
+            values: ["Normal", "Certificado 1"],
+          }),
+        ],
+        universe,
+      }),
+      ["Normal", "Certificado 1"],
+    );
+  });
+
+  it("When include and exclude overlap, it should subtract the excluded values", () => {
+    assert.deepEqual(
+      resolveAllowedRestrictionValues({
+        payeeId: 10,
+        date: "2026-10-28",
+        rules: [
+          rule({
+            payee_id: 10,
+            mode: "include",
+            values: ["Normal", "Certificado 1"],
+          }),
+          rule({
+            payee_id: 10,
+            mode: "exclude",
+            values: ["Certificado 1"],
+            start_date: "2026-10-27",
+            end_date: "2026-11-02",
+          }),
+        ],
+        universe,
+      }),
+      ["Normal"],
+    );
+  });
+
+  it("When the rule belongs to another payee, it should ignore it", () => {
+    assert.equal(
+      filterActiveProviderRestrictions(
+        [
+          rule({
+            payee_id: 99,
+            mode: "exclude",
+            values: ["Normal"],
+          }),
+        ],
+        10,
+        "2026-10-28",
+      ).length,
+      0,
+    );
+  });
+});
+
+describe("matchReceptionTypeCode", () => {
+  const types = [
+    { Nombre: "Certificado", Codigo: "1" },
+    { Nombre: "Normal", Codigo: "N" },
+  ];
+
+  it("When the form value is Nombre + Codigo, it should return the code", () => {
+    assert.equal(matchReceptionTypeCode("Certificado 1", types), "1");
+    assert.equal(matchReceptionTypeCode("1", types), "1");
+  });
+});
+
+describe("isRestrictionValueAllowed", () => {
+  it("When the selected type is excluded, it should reject it", () => {
+    assert.equal(
+      isRestrictionValueAllowed({
+        payeeId: 7,
+        date: "2026-10-28",
+        value: "1",
+        universe: ["N", "1"],
+        rules: [
+          rule({
+            payee_id: 7,
+            mode: "exclude",
+            values: ["1"],
+            start_date: "2026-10-27",
+            end_date: "2026-11-02",
+          }),
+        ],
+      }),
+      false,
+    );
+  });
+});
+
+describe("checkProviderRestrictionValue", () => {
+  it("When blocked, it should return a title and description", () => {
+    const result = checkProviderRestrictionValue({
+      payeeId: 7,
+      date: "2026-10-28",
+      value: "1",
+      valueLabel: "Certificado 1",
+      label: "Tipo",
+      universe: ["N", "1"],
+      rules: [
+        rule({
+          payee_id: 7,
+          mode: "exclude",
+          values: ["1"],
+          start_date: "2026-10-27",
+          end_date: "2026-11-02",
+        }),
+      ],
+    });
+    assert.equal(result.allowed, false);
+    if (!result.allowed) {
+      assert.match(result.description, /no puede usar tipo "Certificado 1"/);
+    }
+  });
+});
+
+describe("validateProviderRestrictionInput", () => {
+  it("When dates are set without a reason, it should require motivo", () => {
+    const errors = validateProviderRestrictionInput({
+      payee_id: 1,
+      mode: "exclude",
+      values: ["1"],
+      start_date: "2026-10-27",
+      end_date: "2026-11-02",
+      motivo: "",
+    });
+    assert.equal(
+      errors.some((error) => error.field === "motivo"),
+      true,
+    );
+  });
+
+  it("When there is no date range, it should not require motivo", () => {
+    const errors = validateProviderRestrictionInput({
+      payee_id: 1,
+      mode: "include",
+      values: ["1"],
+    });
+    assert.deepEqual(errors, []);
+  });
+
+  it("When only one date is set, it should require both", () => {
+    const errors = validateProviderRestrictionInput({
+      payee_id: 1,
+      mode: "exclude",
+      values: ["1"],
+      start_date: "2026-10-27",
+      motivo: "Auditoría",
+    });
+    assert.equal(
+      errors.some((error) => error.field === "start_date"),
+      true,
+    );
+  });
+});

package/src/providerRestrictions.ts

@@ -0,0 +1,295 @@
+import type {
+  ProviderRestrictionCheckResult,
+  ProviderRestrictionMode,
+  ProviderRestrictionRule,
+  ReceptionType,
+} from "@zauru-sdk/types";
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+export const PROVIDER_TYPE_RESTRICTIONS_TABLE_VAR =
+  "ctl_calidad_admin_restricciones_tipos_proveedor_web_app_table_id";
+
+export const PROVIDER_ITEM_RESTRICTIONS_TABLE_VAR =
+  "ctl_calidad_admin_restricciones_verduras_proveedor_web_app_table_id";
+
+export const normalizeRestrictionValue = (
+  value: string | number | undefined | null,
+): string => String(value ?? "").replace(/\s+/g, " ").trim();
+
+export const formatRestrictionTypeValue = (
+  type?: { Nombre?: string; Codigo?: string } | null,
+): string =>
+  [type?.Nombre, type?.Codigo]
+    .map((part) => String(part ?? "").trim())
+    .filter(Boolean)
+    .join(" ");
+
+const assertNever = (value: never): never => {
+  throw new Error(`Unexpected restriction mode: ${String(value)}`);
+};
+
+export const isProviderRestrictionMode = (
+  value: unknown,
+): value is ProviderRestrictionMode =>
+  value === "include" || value === "exclude";
+
+export const normalizeProviderRestrictionValues = (
+  values: unknown,
+): string[] => {
+  if (Array.isArray(values)) {
+    return values.map(normalizeRestrictionValue).filter(Boolean);
+  }
+  if (typeof values === "string") {
+    const trimmed = values.trim();
+    if (!trimmed) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed.map(normalizeRestrictionValue).filter(Boolean);
+      }
+    } catch {
+      return trimmed
+        .split(",")
+        .map((part) => normalizeRestrictionValue(part))
+        .filter(Boolean);
+    }
+  }
+  return [];
+};
+
+export const restrictionHasDateRange = (
+  rule: Pick<ProviderRestrictionRule, "start_date" | "end_date">,
+): boolean =>
+  Boolean(normalizeRestrictionValue(rule.start_date)) ||
+  Boolean(normalizeRestrictionValue(rule.end_date));
+
+export const isRestrictionActiveOnDate = (
+  rule: ProviderRestrictionRule,
+  date: string,
+): boolean => {
+  if (normalizeRestrictionValue(rule.fechaEliminacion)) {
+    return false;
+  }
+  if (!isProviderRestrictionMode(rule.mode)) {
+    return false;
+  }
+  const start = normalizeRestrictionValue(rule.start_date);
+  const end = normalizeRestrictionValue(rule.end_date);
+  if (!start && !end) {
+    return true;
+  }
+  if (!DATE_RE.test(date)) {
+    return false;
+  }
+  if (start && date < start) {
+    return false;
+  }
+  if (end && date > end) {
+    return false;
+  }
+  return true;
+};
+
+export const filterActiveProviderRestrictions = (
+  rules: ProviderRestrictionRule[] | undefined,
+  payeeId: number,
+  date: string,
+): ProviderRestrictionRule[] =>
+  (rules ?? []).filter(
+    (rule) =>
+      Number(rule.payee_id) === Number(payeeId) &&
+      isRestrictionActiveOnDate(rule, date),
+  );
+
+export const resolveAllowedRestrictionValues = (input: {
+  payeeId: number;
+  date: string;
+  rules: ProviderRestrictionRule[] | undefined;
+  universe: Array<string | number>;
+}): string[] => {
+  const universe = input.universe
+    .map(normalizeRestrictionValue)
+    .filter(Boolean);
+  const active = filterActiveProviderRestrictions(
+    input.rules,
+    input.payeeId,
+    input.date,
+  );
+
+  if (active.length === 0) {
+    return universe;
+  }
+
+  const includes = active.filter((rule) => rule.mode === "include");
+  const excludes = active.filter((rule) => rule.mode === "exclude");
+
+  let allowed = universe;
+  if (includes.length > 0) {
+    const union = new Set(
+      includes.flatMap((rule) => normalizeProviderRestrictionValues(rule.values)),
+    );
+    allowed = allowed.filter((value) => union.has(value));
+  }
+
+  if (excludes.length > 0) {
+    const blocked = new Set(
+      excludes.flatMap((rule) => normalizeProviderRestrictionValues(rule.values)),
+    );
+    allowed = allowed.filter((value) => !blocked.has(value));
+  }
+
+  return allowed;
+};
+
+export const isRestrictionValueAllowed = (input: {
+  payeeId: number;
+  date: string;
+  value: string | number;
+  rules: ProviderRestrictionRule[] | undefined;
+  universe: Array<string | number>;
+}): boolean => {
+  const allowed = resolveAllowedRestrictionValues(input);
+  return allowed.includes(normalizeRestrictionValue(input.value));
+};
+
+export const matchReceptionTypeCode = (
+  formValue: string,
+  types: Array<ReceptionType | { data?: ReceptionType }> | undefined,
+): string => {
+  const wanted = normalizeRestrictionValue(formValue);
+  if (!wanted) {
+    return "";
+  }
+
+  for (const entry of types ?? []) {
+    const type =
+      entry && typeof entry === "object" && "data" in entry
+        ? entry.data
+        : (entry as ReceptionType);
+    if (!type) {
+      continue;
+    }
+    const code = normalizeRestrictionValue(type.Codigo);
+    const formatted = formatRestrictionTypeValue(type);
+    if (wanted === code || wanted === formatted) {
+      return code || formatted;
+    }
+  }
+
+  return wanted;
+};
+
+export type ProviderRestrictionInput = {
+  payee_id: number;
+  mode: ProviderRestrictionMode | string;
+  values: unknown;
+  start_date?: string;
+  end_date?: string;
+  motivo?: string;
+};
+
+export type ProviderRestrictionInputError = {
+  field: string;
+  message: string;
+};
+
+export const validateProviderRestrictionInput = (
+  input: ProviderRestrictionInput,
+): ProviderRestrictionInputError[] => {
+  const errors: ProviderRestrictionInputError[] = [];
+  if (!Number(input.payee_id) || Number(input.payee_id) < 1) {
+    errors.push({ field: "payee_id", message: "Seleccione un proveedor." });
+  }
+  if (!isProviderRestrictionMode(input.mode)) {
+    errors.push({
+      field: "mode",
+      message: "Seleccione si se permiten o se bloquean esos valores.",
+    });
+  }
+  if (normalizeProviderRestrictionValues(input.values).length === 0) {
+    errors.push({
+      field: "values",
+      message: "Seleccione al menos un valor.",
+    });
+  }
+
+  const start = normalizeRestrictionValue(input.start_date);
+  const end = normalizeRestrictionValue(input.end_date);
+  if (start || end) {
+    if (!start || !end) {
+      errors.push({
+        field: "start_date",
+        message: "Si usa fechas, indique inicio y fin.",
+      });
+    } else {
+      if (!DATE_RE.test(start) || !DATE_RE.test(end)) {
+        errors.push({
+          field: "start_date",
+          message: "Las fechas deben ir en formato YYYY-MM-DD.",
+        });
+      } else if (start > end) {
+        errors.push({
+          field: "end_date",
+          message: "La fecha fin no puede ser anterior a la fecha inicio.",
+        });
+      }
+    }
+    if (!normalizeRestrictionValue(input.motivo)) {
+      errors.push({
+        field: "motivo",
+        message: "Indique el motivo de la excepción con rango de fechas.",
+      });
+    }
+  }
+
+  return errors;
+};
+
+const describeMode = (mode: ProviderRestrictionMode): string => {
+  switch (mode) {
+    case "include":
+      return "solo puede usar";
+    case "exclude":
+      return "no puede usar";
+    default:
+      return assertNever(mode);
+  }
+};
+
+export const checkProviderRestrictionValue = (input: {
+  payeeId: number;
+  date: string;
+  value: string | number;
+  rules: ProviderRestrictionRule[] | undefined;
+  universe: Array<string | number>;
+  label: string;
+  valueLabel?: string;
+}): ProviderRestrictionCheckResult => {
+  const allowed = isRestrictionValueAllowed(input);
+  if (allowed) {
+    return { allowed: true };
+  }
+
+  const active = filterActiveProviderRestrictions(
+    input.rules,
+    input.payeeId,
+    input.date,
+  );
+  const includes = active.filter((rule) => rule.mode === "include");
+  const mode: ProviderRestrictionMode =
+    includes.length > 0 ? "include" : "exclude";
+  const valueLabel =
+    normalizeRestrictionValue(input.valueLabel) ||
+    normalizeRestrictionValue(input.value);
+
+  return {
+    allowed: false,
+    mode,
+    matchedValues: [valueLabel],
+    title: `${input.label} no permitido para este proveedor`,
+    description: `En la fecha ${input.date} este proveedor ${describeMode(mode)} ${input.label.toLowerCase()} "${valueLabel}".`,
+  };
+};