@zauru-sdk/common 6.14.3 → 6.15.1

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [6.15.1](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.15.0...@zauru-sdk/common@6.15.1) (2026-11-03)
+
+**Note:** Version bump only for package @zauru-sdk/common
+
+
+
+
+
+# [6.15.0](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.14.3...@zauru-sdk/common@6.15.0) (2026-11-03)
+
+
+### Features
+
+* agregar contrato de conversión de radicchio ([50d7efc](https://github.com/intuitiva/zauru-typescript-sdk/commit/50d7efca40cbf4b2b7789a5c4bf636fbd95c515c))
+
+
+
+
+
 ## [6.14.3](https://github.com/intuitiva/zauru-typescript-sdk/compare/@zauru-sdk/common@6.14.2...@zauru-sdk/common@6.14.3) (2026-11-02)
 
 **Note:** Version bump only for package @zauru-sdk/common

package/dist/esm/index.js

@@ -20,5 +20,6 @@ __exportStar(require("./httpClientPolicy.js"), exports);
 __exportStar(require("./oauthErrors.js"), exports);
 __exportStar(require("./providerRestrictions.js"), exports);
 __exportStar(require("./providerReceptionMatrix.js"), exports);
+__exportStar(require("./radicchioConversion.js"), exports);
 __exportStar(require("./rejectionPercentageAdjustment.js"), exports);
 __exportStar(require("./sessionReauth.js"), exports);

package/dist/esm/radicchioConversion.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRadicchioConversionMemo = exports.getRadicchioOriginalLines = exports.allocateRadicchioBoxesByLine = exports.validateRadicchioConversion = exports.calculateRadicchioConversion = exports.emptyRadicchioBoxes = void 0;
+const boxSizes = [9, 12, 15];
+const emptyRadicchioBoxes = () => ({
+    9: 0,
+    12: 0,
+    15: 0,
+});
+exports.emptyRadicchioBoxes = emptyRadicchioBoxes;
+const calculateRadicchioConversion = (receivedUnits, boxes) => {
+    const normalized = Object.fromEntries(boxSizes.map((size) => [size, Number(boxes[size])]));
+    const packedUnits = boxSizes.reduce((total, size) => total + size * normalized[size], 0);
+    return {
+        boxes: normalized,
+        packedUnits,
+        remainingUnits: Number(receivedUnits) - packedUnits,
+        totalBoxes: boxSizes.reduce((total, size) => total + normalized[size], 0),
+    };
+};
+exports.calculateRadicchioConversion = calculateRadicchioConversion;
+const validateRadicchioConversion = (receivedUnits, boxes, remainderReason) => {
+    const errors = [];
+    if (!Number.isInteger(receivedUnits) || receivedUnits <= 0) {
+        errors.push("Las unidades recibidas deben ser un entero mayor que cero.");
+    }
+    for (const size of boxSizes) {
+        if (!Number.isInteger(Number(boxes[size])) || Number(boxes[size]) < 0) {
+            errors.push(`Las cajas de ${size} deben ser un entero mayor o igual a cero.`);
+        }
+    }
+    if (errors.length)
+        return errors;
+    const calculation = (0, exports.calculateRadicchioConversion)(receivedUnits, boxes);
+    if (calculation.totalBoxes <= 0) {
+        errors.push("Ingrese al menos una caja.");
+    }
+    if (calculation.remainingUnits < 0) {
+        errors.push("Las cajas ingresadas superan las unidades recibidas.");
+    }
+    if (calculation.remainingUnits > 0 &&
+        !String(remainderReason ?? "").trim()) {
+        errors.push("Indique el motivo de las unidades sin convertir.");
+    }
+    return errors;
+};
+exports.validateRadicchioConversion = validateRadicchioConversion;
+/**
+ * Splits a converted box total across original weighing lines while preserving
+ * the exact total. Floors every proportional share, then assigns the remaining
+ * boxes to the largest fractional residues (stable by original line order).
+ */
+const allocateRadicchioBoxesByLine = (totalBoxes, lineUnits) => {
+    if (!Number.isInteger(totalBoxes) || totalBoxes < 0) {
+        throw new Error("El total de cajas debe ser un entero mayor o igual a cero.");
+    }
+    if (!lineUnits.length)
+        return [];
+    const normalized = lineUnits.map((value) => Math.max(0, Number(value) || 0));
+    const unitTotal = normalized.reduce((sum, value) => sum + value, 0);
+    if (unitTotal <= 0) {
+        return normalized.map((_, index) => (index === 0 ? totalBoxes : 0));
+    }
+    const ideals = normalized.map((value) => (totalBoxes * value) / unitTotal);
+    const allocated = ideals.map(Math.floor);
+    let remaining = totalBoxes - allocated.reduce((sum, value) => sum + value, 0);
+    const order = ideals
+        .map((value, index) => ({ index, residue: value - Math.floor(value) }))
+        .sort((a, b) => b.residue - a.residue || a.index - b.index);
+    for (let index = 0; index < remaining; index += 1) {
+        allocated[order[index].index] += 1;
+    }
+    return allocated;
+};
+exports.allocateRadicchioBoxesByLine = allocateRadicchioBoxesByLine;
+const getRadicchioOriginalLines = (memo) => {
+    const lines = memo.originalNetWeightLines ?? memo.originalNetWeighLines ?? [];
+    if (lines.length)
+        return lines.map((line) => Number(line.weight) || 0);
+    const total = Number(memo.radicchioConversion?.receivedUnits ?? memo.originalNetWeight ?? 0);
+    return total > 0 ? [total] : [];
+};
+exports.getRadicchioOriginalLines = getRadicchioOriginalLines;
+const isRadicchioConversionMemo = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const memo = value;
+    return (memo.schemaVersion === 1 &&
+        (memo.status === "pending" || memo.status === "converted") &&
+        Number.isInteger(memo.sourceItemId) &&
+        Number.isInteger(memo.targetItemId) &&
+        Number.isFinite(memo.receivedUnits));
+};
+exports.isRadicchioConversionMemo = isRadicchioConversionMemo;

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
 export * from "./providerReceptionMatrix.js";
+export * from "./radicchioConversion.js";
 export * from "./rejectionPercentageAdjustment.js";
 export * from "./sessionReauth.js";

package/dist/radicchioConversion.d.ts

@@ -0,0 +1,18 @@
+import type { JsonMemoType, RadicchioBoxes, RadicchioConversionMemo } from "@zauru-sdk/types";
+export type RadicchioConversionCalculation = {
+    boxes: RadicchioBoxes;
+    packedUnits: number;
+    remainingUnits: number;
+    totalBoxes: number;
+};
+export declare const emptyRadicchioBoxes: () => RadicchioBoxes;
+export declare const calculateRadicchioConversion: (receivedUnits: number, boxes: RadicchioBoxes) => RadicchioConversionCalculation;
+export declare const validateRadicchioConversion: (receivedUnits: number, boxes: RadicchioBoxes, remainderReason?: string) => string[];
+/**
+ * Splits a converted box total across original weighing lines while preserving
+ * the exact total. Floors every proportional share, then assigns the remaining
+ * boxes to the largest fractional residues (stable by original line order).
+ */
+export declare const allocateRadicchioBoxesByLine: (totalBoxes: number, lineUnits: number[]) => number[];
+export declare const getRadicchioOriginalLines: (memo: JsonMemoType) => number[];
+export declare const isRadicchioConversionMemo: (value: unknown) => value is RadicchioConversionMemo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauru-sdk/common",
-  "version": "6.14.3",
+  "version": "6.15.1",
   "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 src/providerReceptionMatrix.test.ts src/purchaseOrderFinancials.test.ts src/sessionReauth.test.ts"
+    "test": "tsx --test src/httpClientPolicy.test.ts src/providerRestrictions.test.ts src/providerReceptionMatrix.test.ts src/purchaseOrderFinancials.test.ts src/radicchioConversion.test.ts src/sessionReauth.test.ts"
   },
   "author": "Oscar Cuéllar",
   "license": "MIT",
@@ -22,9 +22,9 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/types": "^6.31.0",
+    "@zauru-sdk/types": "^6.32.1",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "f5b9a14e062a1c9715757cefc08b82a2f3ffd1bf"
+  "gitHead": "ec249a3005f95dd2215592b4d31068a76e31eca5"
 }

package/src/index.ts

@@ -4,5 +4,6 @@ export * from "./httpClientPolicy.js";
 export * from "./oauthErrors.js";
 export * from "./providerRestrictions.js";
 export * from "./providerReceptionMatrix.js";
+export * from "./radicchioConversion.js";
 export * from "./rejectionPercentageAdjustment.js";
 export * from "./sessionReauth.js";

package/src/radicchioConversion.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  allocateRadicchioBoxesByLine,
+  calculateRadicchioConversion,
+  getRadicchioOriginalLines,
+  validateRadicchioConversion,
+} from "./radicchioConversion.js";
+
+describe("radicchio conversion", () => {
+  it("calculates boxes, packed units and remainder", () => {
+    assert.deepEqual(
+      calculateRadicchioConversion(100, { 9: 2, 12: 3, 15: 2 }),
+      {
+      boxes: { 9: 2, 12: 3, 15: 2 },
+      packedUnits: 84,
+      remainingUnits: 16,
+      totalBoxes: 7,
+      },
+    );
+  });
+
+  it("requires a reason when units remain", () => {
+    assert.ok(
+      validateRadicchioConversion(100, { 9: 10, 12: 0, 15: 0 }).includes(
+        "Indique el motivo de las unidades sin convertir.",
+      ),
+    );
+    assert.deepEqual(
+      validateRadicchioConversion(
+        100,
+        { 9: 10, 12: 0, 15: 0 },
+        "Unidades sueltas",
+      ),
+      [],
+    );
+  });
+
+  it("rejects over-allocation and non-integer boxes", () => {
+    assert.ok(
+      validateRadicchioConversion(10, { 9: 0, 12: 1, 15: 0 }).includes(
+        "Las cajas ingresadas superan las unidades recibidas.",
+      ),
+    );
+    assert.ok(
+      validateRadicchioConversion(100, { 9: 1.5, 12: 0, 15: 0 }).includes(
+        "Las cajas de 9 deben ser un entero mayor o igual a cero.",
+      ),
+    );
+  });
+
+  it("allocates boxes by largest residue and preserves the total", () => {
+    const result = allocateRadicchioBoxesByLine(10, [50, 30, 20]);
+    assert.deepEqual(result, [5, 3, 2]);
+    assert.equal(result.reduce((sum, value) => sum + value, 0), 10);
+  });
+
+  it("reads the corrected and legacy line keys", () => {
+    assert.deepEqual(
+      getRadicchioOriginalLines({ originalNetWeightLines: [{ weight: 12 }] }),
+      [12],
+    );
+    assert.deepEqual(
+      getRadicchioOriginalLines({ originalNetWeighLines: [{ weight: 15 }] }),
+      [15],
+    );
+  });
+});

package/src/radicchioConversion.ts

@@ -0,0 +1,128 @@
+import type {
+  JsonMemoType,
+  RadicchioBoxes,
+  RadicchioConversionMemo,
+} from "@zauru-sdk/types";
+
+export type RadicchioConversionCalculation = {
+  boxes: RadicchioBoxes;
+  packedUnits: number;
+  remainingUnits: number;
+  totalBoxes: number;
+};
+
+const boxSizes = [9, 12, 15] as const;
+
+export const emptyRadicchioBoxes = (): RadicchioBoxes => ({
+  9: 0,
+  12: 0,
+  15: 0,
+});
+
+export const calculateRadicchioConversion = (
+  receivedUnits: number,
+  boxes: RadicchioBoxes,
+): RadicchioConversionCalculation => {
+  const normalized = Object.fromEntries(
+    boxSizes.map((size) => [size, Number(boxes[size])]),
+  ) as RadicchioBoxes;
+  const packedUnits = boxSizes.reduce(
+    (total, size) => total + size * normalized[size],
+    0,
+  );
+  return {
+    boxes: normalized,
+    packedUnits,
+    remainingUnits: Number(receivedUnits) - packedUnits,
+    totalBoxes: boxSizes.reduce(
+      (total, size) => total + normalized[size],
+      0,
+    ),
+  };
+};
+
+export const validateRadicchioConversion = (
+  receivedUnits: number,
+  boxes: RadicchioBoxes,
+  remainderReason?: string,
+): string[] => {
+  const errors: string[] = [];
+  if (!Number.isInteger(receivedUnits) || receivedUnits <= 0) {
+    errors.push("Las unidades recibidas deben ser un entero mayor que cero.");
+  }
+  for (const size of boxSizes) {
+    if (!Number.isInteger(Number(boxes[size])) || Number(boxes[size]) < 0) {
+      errors.push(`Las cajas de ${size} deben ser un entero mayor o igual a cero.`);
+    }
+  }
+  if (errors.length) return errors;
+
+  const calculation = calculateRadicchioConversion(receivedUnits, boxes);
+  if (calculation.totalBoxes <= 0) {
+    errors.push("Ingrese al menos una caja.");
+  }
+  if (calculation.remainingUnits < 0) {
+    errors.push("Las cajas ingresadas superan las unidades recibidas.");
+  }
+  if (
+    calculation.remainingUnits > 0 &&
+    !String(remainderReason ?? "").trim()
+  ) {
+    errors.push("Indique el motivo de las unidades sin convertir.");
+  }
+  return errors;
+};
+
+/**
+ * Splits a converted box total across original weighing lines while preserving
+ * the exact total. Floors every proportional share, then assigns the remaining
+ * boxes to the largest fractional residues (stable by original line order).
+ */
+export const allocateRadicchioBoxesByLine = (
+  totalBoxes: number,
+  lineUnits: number[],
+): number[] => {
+  if (!Number.isInteger(totalBoxes) || totalBoxes < 0) {
+    throw new Error("El total de cajas debe ser un entero mayor o igual a cero.");
+  }
+  if (!lineUnits.length) return [];
+  const normalized = lineUnits.map((value) => Math.max(0, Number(value) || 0));
+  const unitTotal = normalized.reduce((sum, value) => sum + value, 0);
+  if (unitTotal <= 0) {
+    return normalized.map((_, index) => (index === 0 ? totalBoxes : 0));
+  }
+
+  const ideals = normalized.map((value) => (totalBoxes * value) / unitTotal);
+  const allocated = ideals.map(Math.floor);
+  let remaining = totalBoxes - allocated.reduce((sum, value) => sum + value, 0);
+  const order = ideals
+    .map((value, index) => ({ index, residue: value - Math.floor(value) }))
+    .sort((a, b) => b.residue - a.residue || a.index - b.index);
+  for (let index = 0; index < remaining; index += 1) {
+    allocated[order[index].index] += 1;
+  }
+  return allocated;
+};
+
+export const getRadicchioOriginalLines = (memo: JsonMemoType): number[] => {
+  const lines = memo.originalNetWeightLines ?? memo.originalNetWeighLines ?? [];
+  if (lines.length) return lines.map((line) => Number(line.weight) || 0);
+  const total = Number(
+    memo.radicchioConversion?.receivedUnits ?? memo.originalNetWeight ?? 0,
+  );
+  return total > 0 ? [total] : [];
+};
+
+export const isRadicchioConversionMemo = (
+  value: unknown,
+): value is RadicchioConversionMemo => {
+  if (!value || typeof value !== "object") return false;
+  const memo = value as Partial<RadicchioConversionMemo>;
+  return (
+    memo.schemaVersion === 1 &&
+    (memo.status === "pending" || memo.status === "converted") &&
+    Number.isInteger(memo.sourceItemId) &&
+    Number.isInteger(memo.targetItemId) &&
+    Number.isFinite(memo.receivedUnits)
+  );
+};