@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/money/money.js

@@ -0,0 +1,380 @@
+import { intlLocaleOf, toolkitSettings } from "../toolkit/toolkitSettings.js";
+const MONEY_ROUNDING = Object.freeze({
+  // la mitad se aleja del cero: 2.345 → 2.35 y −2.345 → −2.35 (como se redondea a mano)
+  halfUp: "halfUp",
+  // la mitad va al par: 2.345 → 2.34 y 2.355 → 2.36 (redondeo bancario: en muchas sumas no carga hacia arriba)
+  halfEven: "halfEven",
+  // corta hacia el cero: 2.349 → 2.34 (lo que hacen el Money de PHP y el de Go al leer)
+  down: "down"
+});
+const DEFAULT_ROUNDING = MONEY_ROUNDING.halfUp;
+const PLAIN_NUMBER = /^-?\d+(\.\d+)?$/;
+const DECIMAL_POINT = ".";
+const NEGATIVE_SIGN = "-";
+const TEN = 10n;
+const formatterCache = /* @__PURE__ */ new Map();
+function decimalsOfCurrency(currency) {
+  return new Intl.NumberFormat("en", { style: "currency", currency }).resolvedOptions().maximumFractionDigits;
+}
+function settingsOf({ currency, decimals } = {}) {
+  const chosenCurrency = currency ?? toolkitSettings().currency;
+  const chosenDecimals = decimals ?? decimalsOfCurrency(chosenCurrency);
+  if (!Number.isInteger(chosenDecimals) || chosenDecimals < 0) {
+    throw new RangeError(`Los decimales de un monto son un entero de 0 en adelante, no ${decimals}`);
+  }
+  return { currency: chosenCurrency, decimals: chosenDecimals };
+}
+function scaledIntegerOf(text) {
+  const [integerText, decimalText = ""] = text.split(DECIMAL_POINT);
+  return { units: BigInt(`${integerText}${decimalText}`), scale: decimalText.length };
+}
+function textOfNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${value} no es un monto de dinero`);
+  }
+  return String(value);
+}
+function factorOf(value) {
+  const text = typeof value === "number" ? textOfNumber(value) : value;
+  if (typeof text !== "string" || !PLAIN_NUMBER.test(text)) {
+    throw new TypeError(`«${value}» no es un número simple para operar con un monto (sin comas, espacios ni exponente)`);
+  }
+  return scaledIntegerOf(text);
+}
+function divideRounded(numerator, denominator, rounding) {
+  const isNegative = numerator < 0n !== denominator < 0n;
+  const positiveNumerator = numerator < 0n ? -numerator : numerator;
+  const positiveDenominator = denominator < 0n ? -denominator : denominator;
+  let quotient = positiveNumerator / positiveDenominator;
+  const twiceRemainder = positiveNumerator % positiveDenominator * 2n;
+  if (rounding === MONEY_ROUNDING.halfUp && twiceRemainder >= positiveDenominator) {
+    quotient += 1n;
+  } else if (rounding === MONEY_ROUNDING.halfEven && (twiceRemainder > positiveDenominator || twiceRemainder === positiveDenominator && quotient % 2n === 1n)) {
+    quotient += 1n;
+  } else if (!Object.values(MONEY_ROUNDING).includes(rounding)) {
+    throw new RangeError(`«${rounding}» no es un modo de redondeo de MONEY_ROUNDING`);
+  }
+  return isNegative ? -quotient : quotient;
+}
+function floorSquareRoot(value) {
+  let root = BigInt(Math.floor(Math.sqrt(Number(value))));
+  while (root * root > value) {
+    root -= 1n;
+  }
+  while ((root + 1n) * (root + 1n) <= value) {
+    root += 1n;
+  }
+  return root;
+}
+function safeMinorUnitsOf(minorUnits) {
+  if (minorUnits > BigInt(Number.MAX_SAFE_INTEGER) || minorUnits < BigInt(Number.MIN_SAFE_INTEGER)) {
+    throw new RangeError("El monto pasa del tope que JavaScript guarda exacto (unos 90 billones con dos decimales)");
+  }
+  return Number(minorUnits);
+}
+class Money {
+  /**
+   * Centavos (la unidad menor de la moneda): 1050 son $10.50.
+   *
+   * @readonly
+   * @type {number}
+   */
+  minorUnits;
+  /**
+   * Código ISO 4217 de la moneda.
+   *
+   * @readonly
+   * @type {string}
+   */
+  currency;
+  /**
+   * Cuántos decimales lleva.
+   *
+   * @readonly
+   * @type {number}
+   */
+  decimals;
+  /**
+   * No se usa directo: los montos se arman con Money.fromString, Money.fromNumber, Money.fromMinorUnits o Money.zero.
+   *
+   * @param {number} minorUnits centavos (la unidad menor de la moneda), entero
+   * @param {string} currency código ISO 4217
+   * @param {number} decimals cuántos decimales lleva
+   */
+  constructor(minorUnits, currency, decimals) {
+    if (!Number.isSafeInteger(minorUnits)) {
+      throw new RangeError(`Un monto se guarda en centavos enteros; ${minorUnits} no lo es o pasa del tope de JavaScript`);
+    }
+    this.minorUnits = minorUnits;
+    this.currency = currency;
+    this.decimals = decimals;
+    Object.freeze(this);
+  }
+  /**
+   * Cero, para arrancar una suma.
+   *
+   * @param {object} [options]
+   * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+   * @param {number} [options.decimals] por omisión, los de la moneda
+   * @returns {Money}
+   */
+  static zero(options) {
+    const { currency, decimals } = settingsOf(options);
+    return new Money(0, currency, decimals);
+  }
+  /**
+   * Un monto a partir del texto que manda el API o la base ('1234.50', '-3', '0.5').
+   *
+   * @param {string} text un número simple: sin comas, espacios, símbolo ni exponente
+   * @param {object} [options]
+   * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+   * @param {number} [options.decimals] por omisión, los de la moneda
+   * @returns {Money}
+   */
+  static fromString(text, options) {
+    const { currency, decimals } = settingsOf(options);
+    if (typeof text !== "string" || !PLAIN_NUMBER.test(text)) {
+      throw new TypeError(`«${text}» no es un monto de dinero: se espera un número simple como '1234.50'`);
+    }
+    const { units, scale } = scaledIntegerOf(text);
+    const extraDecimals = scale - decimals;
+    if (extraDecimals <= 0) {
+      return new Money(safeMinorUnitsOf(units * TEN ** BigInt(-extraDecimals)), currency, decimals);
+    }
+    const divisor = TEN ** BigInt(extraDecimals);
+    if (units % divisor !== 0n) {
+      throw new RangeError(`«${text}» trae más de ${decimals} decimales; para no perder centavos, configure más decimales`);
+    }
+    return new Money(safeMinorUnitsOf(units / divisor), currency, decimals);
+  }
+  /**
+   * Un monto a partir de un número del JSON del API (2450.5). Lo que trae decimales de más (lo que deja hacer cuentas
+   * con decimales, como 0.30000000000000004) truena igual que en fromString.
+   *
+   * @param {number} value
+   * @param {object} [options]
+   * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+   * @param {number} [options.decimals] por omisión, los de la moneda
+   * @returns {Money}
+   */
+  static fromNumber(value, options) {
+    if (typeof value !== "number") {
+      throw new TypeError(`fromNumber recibe un número; para el texto del API use fromString («${value}»)`);
+    }
+    return Money.fromString(textOfNumber(value), options);
+  }
+  /**
+   * Un monto a partir de sus centavos enteros (1050 son $10.50).
+   *
+   * @param {number} minorUnits
+   * @param {object} [options]
+   * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+   * @param {number} [options.decimals] por omisión, los de la moneda
+   * @returns {Money}
+   */
+  static fromMinorUnits(minorUnits, options) {
+    const { currency, decimals } = settingsOf(options);
+    return new Money(minorUnits, currency, decimals);
+  }
+  /**
+   * Revisa que el otro monto sea de la misma moneda y con los mismos decimales.
+   *
+   * @param {Money} other
+   * @returns {void}
+   */
+  #assertSameKind(other) {
+    if (!(other instanceof Money)) {
+      throw new TypeError("Solo se opera un monto con otro Money; arme el otro con Money.fromString o Money.fromNumber");
+    }
+    if (other.currency !== this.currency || other.decimals !== this.decimals) {
+      throw new RangeError(`No se mezclan ${this.currency} con ${this.decimals} decimales y ${other.currency} con ${other.decimals}`);
+    }
+  }
+  /**
+   * Un monto nuevo de la misma moneda a partir de un entero grande de centavos.
+   *
+   * @param {bigint} minorUnits
+   * @returns {Money}
+   */
+  #withMinorUnits(minorUnits) {
+    return new Money(safeMinorUnitsOf(minorUnits), this.currency, this.decimals);
+  }
+  /**
+   * Este monto más otro.
+   *
+   * @param {Money} other
+   * @returns {Money}
+   */
+  plus(other) {
+    this.#assertSameKind(other);
+    return this.#withMinorUnits(BigInt(this.minorUnits) + BigInt(other.minorUnits));
+  }
+  /**
+   * Este monto menos otro.
+   *
+   * @param {Money} other
+   * @returns {Money}
+   */
+  minus(other) {
+    this.#assertSameKind(other);
+    return this.#withMinorUnits(BigInt(this.minorUnits) - BigInt(other.minorUnits));
+  }
+  /**
+   * Este monto por un factor (1.16 para el IVA, 3 piezas, '0.5'), redondeado al centavo.
+   *
+   * @param {number|string} factor un número simple; mejor en texto si viene de una tasa ('0.16')
+   * @param {object} [options]
+   * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+   * @returns {Money}
+   */
+  times(factor, { rounding = DEFAULT_ROUNDING } = {}) {
+    const { units, scale } = factorOf(factor);
+    return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) * units, TEN ** BigInt(scale), rounding));
+  }
+  /**
+   * Este monto entre un divisor (3 pagos, '1.16' para quitar el IVA), redondeado al centavo.
+   *
+   * OJO: tres pagos de un tercio redondeado no siempre suman el total (10.00 / 3 = 3.33 y 3 × 3.33 = 9.99). Si las
+   * partes tienen que sumar el total exacto, la última se calcula restando las demás.
+   *
+   * @param {number|string} divisor un número simple, distinto de cero
+   * @param {object} [options]
+   * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+   * @returns {Money}
+   */
+  dividedBy(divisor, { rounding = DEFAULT_ROUNDING } = {}) {
+    const { units, scale } = factorOf(divisor);
+    if (units === 0n) {
+      throw new RangeError("Un monto no se divide entre cero");
+    }
+    return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) * TEN ** BigInt(scale), units, rounding));
+  }
+  /**
+   * Este monto elevado a una potencia entera, redondeado al centavo: (1.05)² = 1.1025 → 1.10.
+   *
+   * @param {number} exponent entero de 0 en adelante
+   * @param {object} [options]
+   * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+   * @returns {Money}
+   */
+  pow(exponent, { rounding = DEFAULT_ROUNDING } = {}) {
+    if (!Number.isInteger(exponent) || exponent < 0) {
+      throw new RangeError(`La potencia de un monto es un entero de 0 en adelante, no ${exponent}; la raíz cuadrada es sqrt()`);
+    }
+    const scale = TEN ** BigInt(this.decimals);
+    const power = BigInt(exponent);
+    return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) ** power * scale, scale ** power, rounding));
+  }
+  /**
+   * La raíz cuadrada de este monto, redondeada al centavo: √2.00 = 1.414… → 1.41.
+   *
+   * @param {object} [options]
+   * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp (en una raíz nunca cae justo en la
+   *     mitad, así que halfEven da lo mismo)
+   * @returns {Money}
+   */
+  sqrt({ rounding = DEFAULT_ROUNDING } = {}) {
+    if (this.minorUnits < 0) {
+      throw new RangeError("Un monto negativo no tiene raíz cuadrada");
+    }
+    if (!Object.values(MONEY_ROUNDING).includes(rounding)) {
+      throw new RangeError(`«${rounding}» no es un modo de redondeo de MONEY_ROUNDING`);
+    }
+    const radicand = BigInt(this.minorUnits) * TEN ** BigInt(this.decimals);
+    const root = floorSquareRoot(radicand);
+    const passesHalf = (2n * root + 1n) ** 2n <= 4n * radicand;
+    const roundsUp = rounding !== MONEY_ROUNDING.down && passesHalf;
+    return this.#withMinorUnits(roundsUp ? root + 1n : root);
+  }
+  /**
+   * Si los dos montos valen exactamente lo mismo, hasta el centavo.
+   *
+   * @param {Money} other
+   * @returns {boolean}
+   */
+  equals(other) {
+    this.#assertSameKind(other);
+    return this.minorUnits === other.minorUnits;
+  }
+  /**
+   * Si este monto es mayor que otro. El centavo de diferencia cuenta.
+   *
+   * @param {Money} other
+   * @returns {boolean}
+   */
+  isGreaterThan(other) {
+    this.#assertSameKind(other);
+    return this.minorUnits > other.minorUnits;
+  }
+  /**
+   * Si el monto es cero o negativo.
+   *
+   * @returns {boolean}
+   */
+  isZeroOrLess() {
+    return this.minorUnits <= 0;
+  }
+  /**
+   * El monto como texto, con todos sus decimales: '1234.50'. Es lo que se le manda al API para una columna NUMERIC.
+   *
+   * @returns {string}
+   */
+  amount() {
+    const sign = this.minorUnits < 0 ? NEGATIVE_SIGN : "";
+    const digits = String(Math.abs(this.minorUnits)).padStart(this.decimals + 1, "0");
+    if (this.decimals === 0) {
+      return `${sign}${digits}`;
+    }
+    return `${sign}${digits.slice(0, -this.decimals)}${DECIMAL_POINT}${digits.slice(-this.decimals)}`;
+  }
+  /**
+   * El monto como lo lee una persona, en el idioma del proveedor y con el símbolo de su moneda: $1,234.50 (es) o
+   * $1,234.50 (en); US$ o ¥ según la moneda. Sin pasar por decimales: Intl recibe el texto exacto.
+   *
+   * @returns {string}
+   */
+  format() {
+    const locale = intlLocaleOf(toolkitSettings().language);
+    const cacheKey = `${locale}|${this.currency}|${this.decimals}`;
+    if (!formatterCache.has(cacheKey)) {
+      formatterCache.set(cacheKey, new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: this.currency,
+        currencyDisplay: "narrowSymbol",
+        minimumFractionDigits: this.decimals,
+        maximumFractionDigits: this.decimals
+      }));
+    }
+    return formatterCache.get(cacheKey).format(this.amount());
+  }
+  /**
+   * Para que JSON.stringify mande el texto del monto ('1234.50') y no un objeto.
+   *
+   * @returns {string}
+   */
+  toJSON() {
+    return this.amount();
+  }
+  /**
+   * Para que un texto con el monto adentro (`${total}`) diga '1234.50'.
+   *
+   * @returns {string}
+   */
+  toString() {
+    return this.amount();
+  }
+  /**
+   * Truena a propósito: `total + iva` o `total > limit` regresarían a los números con decimales sin que nadie se dé
+   * cuenta. Se usa plus, minus, isGreaterThan...
+   *
+   * @returns {never}
+   */
+  valueOf() {
+    throw new TypeError("Un Money no se opera con + - * / > <: use plus, minus, times, dividedBy, isGreaterThan o equals");
+  }
+}
+export {
+  MONEY_ROUNDING,
+  Money
+};
+//# sourceMappingURL=money.js.map

package/dist/money/money.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.js","sources":["../../src/money/money.js"],"sourcesContent":["// Un monto de dinero exacto: un entero de centavos (o de la unidad menor de su moneda), nunca un número con decimales.\n//\n// POR QUÉ EXISTE. En JavaScript los números con decimales no son exactos: 0.1 + 0.2 da 0.30000000000000004. Sumando\n// cientos de importes el error se acumula y el total de la pantalla deja de ser el del servidor. Con centavos enteros,\n// 10 + 20 siempre da 30. Es la misma regla que el Money de PHP (bcmath) y el money.Amount de Go (int64 de centavos):\n// el dinero nunca pasa por un número con decimales.\n//\n// Cómo se usa, y es a propósito que no se parezca a la aritmética normal:\n//\n//   const total = Money.fromString(order.total).plus(Money.fromNumber(order.shipping));\n//   const withTax = total.times('1.16');                   // IVA del 16 %, redondeado al centavo\n//   const perPayment = total.dividedBy(3);                 // tres pagos\n//   if (total.isGreaterThan(Money.fromString('20000'))) { ... }\n//   total.format()                                         // \"$23,450.10\" en el idioma y la moneda del proveedor\n//   total.amount()                                         // \"23450.10\", el texto que se le manda al API\n//\n// Reglas que hace cumplir, para que un error truene al momento y no tres pantallas después:\n//   - un texto que no es un número simple («1,234», « 12», «12.», «») no se lee como cero: truena;\n//   - un monto con más decimales de los de su moneda («10.219» en pesos) truena: cortarlo perdería un centavo sin que\n//     nadie se entere. Los ceros de más sí entran («10.500» son 10.50). Quien necesite más decimales los configura;\n//   - no se suman ni se comparan pesos con dólares, ni montos con distintos decimales: truena;\n//   - `+`, `-`, `>` y `<` truenan (valueOf): con ellos JavaScript volvería a los decimales. Se usa plus, minus,\n//     isGreaterThan...\n//\n// Multiplicar, dividir, la potencia y la raíz sí tienen que redondear (un tercio de 10 pesos no cabe en centavos). Se\n// calculan con enteros grandes (BigInt) y se redondea UNA vez al final, al centavo, con el modo que se pida\n// (MONEY_ROUNDING). Por omisión, la mitad se aleja del cero, como se redondea a mano.\n//\n// Tope: un entero exacto de JavaScript llega a 9,007,199,254,740,991. Con dos decimales son unos 90 billones de pesos;\n// con más decimales, menos. Pasarse truena.\n//\n// Funciones puras, sin React: function y una clase de valor (no se modifica: cada operación regresa un monto nuevo).\nimport {intlLocaleOf, toolkitSettings} from '@/toolkit/toolkitSettings.js';\n\n/** Cómo se redondea al centavo lo que no cabe en centavos (al multiplicar, dividir, elevar o sacar raíz). */\nexport const MONEY_ROUNDING = Object.freeze({\n    // la mitad se aleja del cero: 2.345 → 2.35 y −2.345 → −2.35 (como se redondea a mano)\n    halfUp: 'halfUp',\n    // la mitad va al par: 2.345 → 2.34 y 2.355 → 2.36 (redondeo bancario: en muchas sumas no carga hacia arriba)\n    halfEven: 'halfEven',\n    // corta hacia el cero: 2.349 → 2.34 (lo que hacen el Money de PHP y el de Go al leer)\n    down: 'down',\n});\n\nconst DEFAULT_ROUNDING = MONEY_ROUNDING.halfUp;\n\n// un número simple: signo opcional, dígitos y, si hay punto, dígitos después. Sin comas, espacios ni exponente\nconst PLAIN_NUMBER = /^-?\\d+(\\.\\d+)?$/;\nconst DECIMAL_POINT = '.';\nconst NEGATIVE_SIGN = '-';\nconst TEN = 10n;\n\n// el formateador de Intl de cada idioma, moneda y decimales: crear uno por celda en una tabla de cientos se nota\nconst formatterCache = new Map();\n\n/**\n * Cuántos decimales lleva una moneda según Intl (ISO 4217): MXN y USD 2, JPY 0, KWD 3.\n *\n * @param {string} currency código ISO 4217\n * @returns {number}\n */\nfunction decimalsOfCurrency(currency) {\n    return new Intl.NumberFormat('en', {style: 'currency', currency}).resolvedOptions().maximumFractionDigits;\n}\n\n/**\n * La moneda y los decimales de un monto nuevo: los que se piden o, si no, los del proveedor.\n *\n * OJO: la moneda se fija al CREAR el monto. Un monto armado antes de que ToolkitProvider ponga la moneda del proyecto\n * (una constante de módulo) se queda con la de omisión (MXN); para esos casos se pasa la moneda explícita.\n *\n * @param {{currency?: string, decimals?: number}} options\n * @returns {{currency: string, decimals: number}}\n */\nfunction settingsOf({currency, decimals} = {}) {\n    const chosenCurrency = currency ?? toolkitSettings().currency;\n    const chosenDecimals = decimals ?? decimalsOfCurrency(chosenCurrency);\n    if (!Number.isInteger(chosenDecimals) || chosenDecimals < 0) {\n        throw new RangeError(`Los decimales de un monto son un entero de 0 en adelante, no ${decimals}`);\n    }\n\n    return {currency: chosenCurrency, decimals: chosenDecimals};\n}\n\n/**\n * Un número simple en texto como entero con su escala: '-12.345' → {units: -12345n, scale: 3}.\n *\n * @param {string} text ya revisado con PLAIN_NUMBER\n * @returns {{units: bigint, scale: number}}\n */\nfunction scaledIntegerOf(text) {\n    const [integerText, decimalText = ''] = text.split(DECIMAL_POINT);\n    return {units: BigInt(`${integerText}${decimalText}`), scale: decimalText.length};\n}\n\n/**\n * El texto de un número de JavaScript como lo escribiría una persona: 2450.5 → '2450.5'. JavaScript escribe el número\n * más corto que vuelve al mismo valor, así que lo que llegó como 2450.55 en el JSON sale como '2450.55'.\n *\n * @param {number} value\n * @returns {string}\n */\nfunction textOfNumber(value) {\n    if (!Number.isFinite(value)) {\n        throw new TypeError(`${value} no es un monto de dinero`);\n    }\n    return String(value);\n}\n\n/**\n * Un factor o divisor (1.16, '0.16', 3) como entero con su escala, sin pasar por decimales.\n *\n * @param {number|string} value\n * @returns {{units: bigint, scale: number}}\n */\nfunction factorOf(value) {\n    const text = typeof value === 'number' ? textOfNumber(value) : value;\n    if (typeof text !== 'string' || !PLAIN_NUMBER.test(text)) {\n        throw new TypeError(`«${value}» no es un número simple para operar con un monto (sin comas, espacios ni exponente)`);\n    }\n    return scaledIntegerOf(text);\n}\n\n/**\n * Divide dos enteros grandes y redondea el resultado a entero con el modo pedido.\n *\n * @param {bigint} numerator\n * @param {bigint} denominator distinto de cero\n * @param {string} rounding uno de MONEY_ROUNDING\n * @returns {bigint}\n */\nfunction divideRounded(numerator, denominator, rounding) {\n    const isNegative = (numerator < 0n) !== (denominator < 0n);\n    const positiveNumerator = numerator < 0n ? -numerator : numerator;\n    const positiveDenominator = denominator < 0n ? -denominator : denominator;\n    let quotient = positiveNumerator / positiveDenominator;\n    // lo que sobra, por dos: comparado con el divisor dice si lo que sobra pasa de la mitad, es la mitad o no llega\n    const twiceRemainder = (positiveNumerator % positiveDenominator) * 2n;\n\n    if (rounding === MONEY_ROUNDING.halfUp && twiceRemainder >= positiveDenominator) {\n        quotient += 1n;\n    } else if (rounding === MONEY_ROUNDING.halfEven\n        && (twiceRemainder > positiveDenominator || (twiceRemainder === positiveDenominator && quotient % 2n === 1n))) {\n        quotient += 1n;\n    } else if (!Object.values(MONEY_ROUNDING).includes(rounding)) {\n        throw new RangeError(`«${rounding}» no es un modo de redondeo de MONEY_ROUNDING`);\n    }\n\n    return isNegative ? -quotient : quotient;\n}\n\n/**\n * La raíz cuadrada entera (hacia abajo) de un entero grande que no es negativo.\n *\n * @param {bigint} value\n * @returns {bigint}\n */\nfunction floorSquareRoot(value) {\n    // la raíz con decimales de JavaScript da un punto de partida casi exacto; los dos ciclos lo dejan exacto\n    let root = BigInt(Math.floor(Math.sqrt(Number(value))));\n    while (root * root > value) {\n        root -= 1n;\n    }\n    while ((root + 1n) * (root + 1n) <= value) {\n        root += 1n;\n    }\n    return root;\n}\n\n/**\n * Un entero grande como centavos de JavaScript, si cabe.\n *\n * @param {bigint} minorUnits\n * @returns {number}\n */\nfunction safeMinorUnitsOf(minorUnits) {\n    if (minorUnits > BigInt(Number.MAX_SAFE_INTEGER) || minorUnits < BigInt(Number.MIN_SAFE_INTEGER)) {\n        throw new RangeError('El monto pasa del tope que JavaScript guarda exacto (unos 90 billones con dos decimales)');\n    }\n    return Number(minorUnits);\n}\n\nexport class Money {\n    /**\n     * Centavos (la unidad menor de la moneda): 1050 son $10.50.\n     *\n     * @readonly\n     * @type {number}\n     */\n    minorUnits;\n\n    /**\n     * Código ISO 4217 de la moneda.\n     *\n     * @readonly\n     * @type {string}\n     */\n    currency;\n\n    /**\n     * Cuántos decimales lleva.\n     *\n     * @readonly\n     * @type {number}\n     */\n    decimals;\n\n    /**\n     * No se usa directo: los montos se arman con Money.fromString, Money.fromNumber, Money.fromMinorUnits o Money.zero.\n     *\n     * @param {number} minorUnits centavos (la unidad menor de la moneda), entero\n     * @param {string} currency código ISO 4217\n     * @param {number} decimals cuántos decimales lleva\n     */\n    constructor(minorUnits, currency, decimals) {\n        if (!Number.isSafeInteger(minorUnits)) {\n            throw new RangeError(`Un monto se guarda en centavos enteros; ${minorUnits} no lo es o pasa del tope de JavaScript`);\n        }\n        this.minorUnits = minorUnits;\n        this.currency = currency;\n        this.decimals = decimals;\n        // un monto no cambia nunca: cada operación regresa uno nuevo\n        Object.freeze(this);\n    }\n\n    /**\n     * Cero, para arrancar una suma.\n     *\n     * @param {object} [options]\n     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor\n     * @param {number} [options.decimals] por omisión, los de la moneda\n     * @returns {Money}\n     */\n    static zero(options) {\n        const {currency, decimals} = settingsOf(options);\n        return new Money(0, currency, decimals);\n    }\n\n    /**\n     * Un monto a partir del texto que manda el API o la base ('1234.50', '-3', '0.5').\n     *\n     * @param {string} text un número simple: sin comas, espacios, símbolo ni exponente\n     * @param {object} [options]\n     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor\n     * @param {number} [options.decimals] por omisión, los de la moneda\n     * @returns {Money}\n     */\n    static fromString(text, options) {\n        const {currency, decimals} = settingsOf(options);\n        if (typeof text !== 'string' || !PLAIN_NUMBER.test(text)) {\n            throw new TypeError(`«${text}» no es un monto de dinero: se espera un número simple como '1234.50'`);\n        }\n\n        const {units, scale} = scaledIntegerOf(text);\n        const extraDecimals = scale - decimals;\n        // con decimales de menos se completa con ceros; con decimales de más solo entra si lo de más son ceros\n        if (extraDecimals <= 0) {\n            return new Money(safeMinorUnitsOf(units * TEN ** BigInt(-extraDecimals)), currency, decimals);\n        }\n        const divisor = TEN ** BigInt(extraDecimals);\n        if (units % divisor !== 0n) {\n            throw new RangeError(`«${text}» trae más de ${decimals} decimales; para no perder centavos, configure más decimales`);\n        }\n\n        return new Money(safeMinorUnitsOf(units / divisor), currency, decimals);\n    }\n\n    /**\n     * Un monto a partir de un número del JSON del API (2450.5). Lo que trae decimales de más (lo que deja hacer cuentas\n     * con decimales, como 0.30000000000000004) truena igual que en fromString.\n     *\n     * @param {number} value\n     * @param {object} [options]\n     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor\n     * @param {number} [options.decimals] por omisión, los de la moneda\n     * @returns {Money}\n     */\n    static fromNumber(value, options) {\n        if (typeof value !== 'number') {\n            throw new TypeError(`fromNumber recibe un número; para el texto del API use fromString («${value}»)`);\n        }\n        return Money.fromString(textOfNumber(value), options);\n    }\n\n    /**\n     * Un monto a partir de sus centavos enteros (1050 son $10.50).\n     *\n     * @param {number} minorUnits\n     * @param {object} [options]\n     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor\n     * @param {number} [options.decimals] por omisión, los de la moneda\n     * @returns {Money}\n     */\n    static fromMinorUnits(minorUnits, options) {\n        const {currency, decimals} = settingsOf(options);\n        return new Money(minorUnits, currency, decimals);\n    }\n\n    /**\n     * Revisa que el otro monto sea de la misma moneda y con los mismos decimales.\n     *\n     * @param {Money} other\n     * @returns {void}\n     */\n    #assertSameKind(other) {\n        if (!(other instanceof Money)) {\n            throw new TypeError('Solo se opera un monto con otro Money; arme el otro con Money.fromString o Money.fromNumber');\n        }\n        if (other.currency !== this.currency || other.decimals !== this.decimals) {\n            throw new RangeError(`No se mezclan ${this.currency} con ${this.decimals} decimales y ${other.currency} con ${other.decimals}`);\n        }\n    }\n\n    /**\n     * Un monto nuevo de la misma moneda a partir de un entero grande de centavos.\n     *\n     * @param {bigint} minorUnits\n     * @returns {Money}\n     */\n    #withMinorUnits(minorUnits) {\n        return new Money(safeMinorUnitsOf(minorUnits), this.currency, this.decimals);\n    }\n\n    /**\n     * Este monto más otro.\n     *\n     * @param {Money} other\n     * @returns {Money}\n     */\n    plus(other) {\n        this.#assertSameKind(other);\n        return this.#withMinorUnits(BigInt(this.minorUnits) + BigInt(other.minorUnits));\n    }\n\n    /**\n     * Este monto menos otro.\n     *\n     * @param {Money} other\n     * @returns {Money}\n     */\n    minus(other) {\n        this.#assertSameKind(other);\n        return this.#withMinorUnits(BigInt(this.minorUnits) - BigInt(other.minorUnits));\n    }\n\n    /**\n     * Este monto por un factor (1.16 para el IVA, 3 piezas, '0.5'), redondeado al centavo.\n     *\n     * @param {number|string} factor un número simple; mejor en texto si viene de una tasa ('0.16')\n     * @param {object} [options]\n     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp\n     * @returns {Money}\n     */\n    times(factor, {rounding = DEFAULT_ROUNDING} = {}) {\n        const {units, scale} = factorOf(factor);\n        return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) * units, TEN ** BigInt(scale), rounding));\n    }\n\n    /**\n     * Este monto entre un divisor (3 pagos, '1.16' para quitar el IVA), redondeado al centavo.\n     *\n     * OJO: tres pagos de un tercio redondeado no siempre suman el total (10.00 / 3 = 3.33 y 3 × 3.33 = 9.99). Si las\n     * partes tienen que sumar el total exacto, la última se calcula restando las demás.\n     *\n     * @param {number|string} divisor un número simple, distinto de cero\n     * @param {object} [options]\n     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp\n     * @returns {Money}\n     */\n    dividedBy(divisor, {rounding = DEFAULT_ROUNDING} = {}) {\n        const {units, scale} = factorOf(divisor);\n        if (units === 0n) {\n            throw new RangeError('Un monto no se divide entre cero');\n        }\n        return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) * TEN ** BigInt(scale), units, rounding));\n    }\n\n    /**\n     * Este monto elevado a una potencia entera, redondeado al centavo: (1.05)² = 1.1025 → 1.10.\n     *\n     * @param {number} exponent entero de 0 en adelante\n     * @param {object} [options]\n     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp\n     * @returns {Money}\n     */\n    pow(exponent, {rounding = DEFAULT_ROUNDING} = {}) {\n        if (!Number.isInteger(exponent) || exponent < 0) {\n            throw new RangeError(`La potencia de un monto es un entero de 0 en adelante, no ${exponent}; la raíz cuadrada es sqrt()`);\n        }\n        // el monto es centavos / 10^decimales; elevado a la n y vuelto a centavos queda centavos^n / 10^(decimales·(n−1))\n        const scale = TEN ** BigInt(this.decimals);\n        const power = BigInt(exponent);\n        return this.#withMinorUnits(divideRounded(BigInt(this.minorUnits) ** power * scale, scale ** power, rounding));\n    }\n\n    /**\n     * La raíz cuadrada de este monto, redondeada al centavo: √2.00 = 1.414… → 1.41.\n     *\n     * @param {object} [options]\n     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp (en una raíz nunca cae justo en la\n     *     mitad, así que halfEven da lo mismo)\n     * @returns {Money}\n     */\n    sqrt({rounding = DEFAULT_ROUNDING} = {}) {\n        if (this.minorUnits < 0) {\n            throw new RangeError('Un monto negativo no tiene raíz cuadrada');\n        }\n        if (!Object.values(MONEY_ROUNDING).includes(rounding)) {\n            throw new RangeError(`«${rounding}» no es un modo de redondeo de MONEY_ROUNDING`);\n        }\n        // la raíz en centavos es √(centavos × 10^decimales)\n        const radicand = BigInt(this.minorUnits) * TEN ** BigInt(this.decimals);\n        const root = floorSquareRoot(radicand);\n        // ¿pasa de la mitad? (raíz + ½)² ≤ radicando, multiplicado por 4 para no salir de los enteros\n        const passesHalf = (2n * root + 1n) ** 2n <= 4n * radicand;\n        const roundsUp = rounding !== MONEY_ROUNDING.down && passesHalf;\n\n        return this.#withMinorUnits(roundsUp ? root + 1n : root);\n    }\n\n    /**\n     * Si los dos montos valen exactamente lo mismo, hasta el centavo.\n     *\n     * @param {Money} other\n     * @returns {boolean}\n     */\n    equals(other) {\n        this.#assertSameKind(other);\n        return this.minorUnits === other.minorUnits;\n    }\n\n    /**\n     * Si este monto es mayor que otro. El centavo de diferencia cuenta.\n     *\n     * @param {Money} other\n     * @returns {boolean}\n     */\n    isGreaterThan(other) {\n        this.#assertSameKind(other);\n        return this.minorUnits > other.minorUnits;\n    }\n\n    /**\n     * Si el monto es cero o negativo.\n     *\n     * @returns {boolean}\n     */\n    isZeroOrLess() {\n        return this.minorUnits <= 0;\n    }\n\n    /**\n     * El monto como texto, con todos sus decimales: '1234.50'. Es lo que se le manda al API para una columna NUMERIC.\n     *\n     * @returns {string}\n     */\n    amount() {\n        const sign = this.minorUnits < 0 ? NEGATIVE_SIGN : '';\n        // los centavos con ceros a la izquierda hasta tener un entero y sus decimales: 5 → '005' → '0.05'\n        const digits = String(Math.abs(this.minorUnits)).padStart(this.decimals + 1, '0');\n        if (this.decimals === 0) {\n            return `${sign}${digits}`;\n        }\n        return `${sign}${digits.slice(0, -this.decimals)}${DECIMAL_POINT}${digits.slice(-this.decimals)}`;\n    }\n\n    /**\n     * El monto como lo lee una persona, en el idioma del proveedor y con el símbolo de su moneda: $1,234.50 (es) o\n     * $1,234.50 (en); US$ o ¥ según la moneda. Sin pasar por decimales: Intl recibe el texto exacto.\n     *\n     * @returns {string}\n     */\n    format() {\n        const locale = intlLocaleOf(toolkitSettings().language);\n        const cacheKey = `${locale}|${this.currency}|${this.decimals}`;\n        if (!formatterCache.has(cacheKey)) {\n            formatterCache.set(cacheKey, new Intl.NumberFormat(locale, {\n                style: 'currency', currency: this.currency, currencyDisplay: 'narrowSymbol',\n                minimumFractionDigits: this.decimals, maximumFractionDigits: this.decimals,\n            }));\n        }\n        return formatterCache.get(cacheKey).format(this.amount());\n    }\n\n    /**\n     * Para que JSON.stringify mande el texto del monto ('1234.50') y no un objeto.\n     *\n     * @returns {string}\n     */\n    toJSON() {\n        return this.amount();\n    }\n\n    /**\n     * Para que un texto con el monto adentro (`${total}`) diga '1234.50'.\n     *\n     * @returns {string}\n     */\n    toString() {\n        return this.amount();\n    }\n\n    /**\n     * Truena a propósito: `total + iva` o `total > limit` regresarían a los números con decimales sin que nadie se dé\n     * cuenta. Se usa plus, minus, isGreaterThan...\n     *\n     * @returns {never}\n     */\n    valueOf() {\n        throw new TypeError('Un Money no se opera con + - * / > <: use plus, minus, times, dividedBy, isGreaterThan o equals');\n    }\n}\n"],"names":[],"mappings":"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"}

package/dist/money.js

@@ -0,0 +1,6 @@
+import { MONEY_ROUNDING, Money } from "./money/money.js";
+export {
+  MONEY_ROUNDING,
+  Money
+};
+//# sourceMappingURL=money.js.map

package/dist/money.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/navigation/appMenu.js

@@ -0,0 +1,93 @@
+const LAST_ORDER = 1e3;
+const HOME_PATH = "/";
+function composeMenu(menuModules, { canAccess = () => true, context = {} } = {}) {
+  const modules = Array.isArray(menuModules) ? menuModules : Object.values(menuModules);
+  return modules.filter((menuModule) => canAccess(menuModule.access)).sort((first, second) => (first.order ?? LAST_ORDER) - (second.order ?? LAST_ORDER)).flatMap((menuModule) => menuModule.buildMenuItems?.(context) ?? [menuModule.buildMenuItem?.(context)]).filter((menuItem) => Boolean(menuItem) && canAccess(menuItem.access)).map((menuItem) => withAllowedChildren(menuItem, canAccess)).filter((menuItem) => Boolean(menuItem.to) || menuItem.children?.length > 0);
+}
+function withAllowedChildren(menuItem, canAccess) {
+  if (!Array.isArray(menuItem.children)) {
+    return menuItem;
+  }
+  return { ...menuItem, children: menuItem.children.filter((child) => Boolean(child) && canAccess(child.access)) };
+}
+function screenMenuItemsOf(menuItems) {
+  return menuItems.flatMap((menuItem) => [menuItem, ...menuItem.children ?? []]).filter((menuItem) => Boolean(menuItem.to));
+}
+function isChildMenuItem(menuItems, menuItem) {
+  return menuItems.some((candidate) => candidate.children?.includes(menuItem));
+}
+function activeMenuItemOf(menuItems, pathname) {
+  const matchingItems = screenMenuItemsOf(menuItems).filter((menuItem) => {
+    const prefix = menuItem.matchPrefix ?? menuItem.to;
+    const isHome = prefix === HOME_PATH;
+    return pathname === prefix || !isHome && pathname.startsWith(`${prefix}/`);
+  });
+  matchingItems.sort((first, second) => {
+    const lengthDifference = (second.matchPrefix ?? second.to).length - (first.matchPrefix ?? first.to).length;
+    if (lengthDifference !== 0) {
+      return lengthDifference;
+    }
+    return Number(isChildMenuItem(menuItems, second)) - Number(isChildMenuItem(menuItems, first));
+  });
+  return matchingItems[0] ?? null;
+}
+function parentMenuItemOf(menuItems, menuItem) {
+  return menuItems.find((candidate) => candidate.children?.includes(menuItem)) ?? null;
+}
+function menuBreadcrumbsOf(menuItems, pathname) {
+  const activeItem = activeMenuItemOf(menuItems, pathname);
+  if (!activeItem) {
+    return [];
+  }
+  const homeItem = menuItems.find((menuItem) => menuItem.to === HOME_PATH) ?? null;
+  const parentItem = parentMenuItemOf(menuItems, activeItem);
+  return [homeItem, parentItem, activeItem].filter((menuItem, index, crumbs) => Boolean(menuItem) && crumbs.indexOf(menuItem) === index);
+}
+function menuBadgeOf(menuItem, menuBadges = {}) {
+  const countOf = (item) => {
+    const count = item.badgeKey ? Number(menuBadges[item.badgeKey] ?? 0) : 0;
+    return Number.isFinite(count) && count > 0 ? count : 0;
+  };
+  const ownCount = countOf(menuItem);
+  const childrenCount = Array.isArray(menuItem.children) ? menuItem.children.reduce((total2, child) => total2 + countOf(child), 0) : 0;
+  const total = ownCount + childrenCount;
+  if (total > 0) {
+    return { content: total, isCount: true };
+  }
+  if (menuItem.badge !== void 0 && menuItem.badge !== null && menuItem.badge !== "") {
+    return { content: menuItem.badge, isCount: typeof menuItem.badge === "number" };
+  }
+  return null;
+}
+const MOBILE_TAB_LIMIT = 5;
+const PINNABLE_TAB_LIMIT = MOBILE_TAB_LIMIT - 1;
+function menuItemKeyOf(menuItem) {
+  return menuItem.to ?? menuItem.labelKey ?? menuItem.label;
+}
+function mobileTabsOf(menuItems, pinnedKeys = null, tabLimit = MOBILE_TAB_LIMIT) {
+  if (menuItems.length <= tabLimit) {
+    return { tabs: menuItems, more: [] };
+  }
+  const pinned = menuItems.filter((menuItem) => (pinnedKeys ?? []).includes(menuItemKeyOf(menuItem)));
+  const marked = menuItems.filter((menuItem) => menuItem.mobileTab);
+  let candidates = menuItems;
+  if (pinned.length > 0) {
+    candidates = pinned;
+  } else if (marked.length > 0) {
+    candidates = marked;
+  }
+  const tabs = candidates.slice(0, Math.max(tabLimit - 1, 1));
+  return { tabs, more: menuItems.filter((menuItem) => !tabs.includes(menuItem)) };
+}
+export {
+  PINNABLE_TAB_LIMIT,
+  activeMenuItemOf,
+  composeMenu,
+  menuBadgeOf,
+  menuBreadcrumbsOf,
+  menuItemKeyOf,
+  mobileTabsOf,
+  parentMenuItemOf,
+  screenMenuItemsOf
+};
+//# sourceMappingURL=appMenu.js.map

package/dist/navigation/appMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"appMenu.js","sources":["../../src/navigation/appMenu.js"],"sourcesContent":["// El menú de la app: COMPUESTO, no escrito.\n//\n// Cada módulo declara su entrada en su propia carpeta (modules/<módulo>/menu.js) y aquí solo se juntan, se filtran por\n// permiso y se ordenan. Módulo nuevo con menú = cero ediciones en una lista central, y nadie pisa la entrada del vecino al\n// resolver un merge.\n//\n// Forma de un menu.js:\n//   export const order = 10;                           // posición en el menú (los que no dicen, al final)\n//   export const access = {ability: 'orders.view'};    // la regla de quién lo ve (accessRules.js); sin ella, todos\n//   export function buildMenuItem(context) {           // o buildMenuItems (en plural) para dos o más entradas\n//       return {\n//           to: '/orders', label: 'Pedidos',           // o labelKey: 'orders:menu.label' (se traduce al pintarse)\n//           description: 'Todos los pedidos…',         // o descriptionKey: para las tarjetas de un inicio\n//           section: 'Operación',                      // o sectionKey: el título de la sección del menú lateral\n//           Icon: ReceiptLongOutlinedIcon,\n//           badge: 3,                                  // opcional: el numerito o la palabra a la derecha («Nuevo»)\n//           mobileTab: true,                           // opcional: va en la barra de pestañas del teléfono (mobileTabsOf)\n//           badgeKey: 'pendingPayment',                 // opcional: su conteo llega del servidor (AppLayout menuBadges)\n//           matchPrefix: '/orders',                    // opcional: desde dónde se marca activo (por omisión, to)\n//           access: {...},                             // opcional: una entrada con otra regla que su módulo\n//           children: [{to: '/orders/returns', label: 'Devoluciones', access: {...}}],   // opcional: un submenú\n//       };\n//   }\n// buildMenuItem puede regresar null (una pantalla apagada por configuración): no sale. Un submenú se filtra igual que las\n// entradas, y si se queda sin hijas (y no lleva a ninguna pantalla propia) no sale.\n//\n// El proyecto le pasa los módulos con el glob de Vite (o una lista, en otro empaquetador):\n//   const menuModules = import.meta.glob('@/modules/*/menu.js', {eager: true});\n//   const menuItems = composeMenu(menuModules, {canAccess, context: {session}});\n//\n// Funciones puras, sin React: function (regla de la casa). Se prueban con node --test (appMenu.test.js).\n\n// la posición de un módulo que no dice su order: al final\nconst LAST_ORDER = 1000;\n\n// la dirección del inicio: la primera miga\nconst HOME_PATH = '/';\n\n/**\n * Las entradas del menú que le tocan a esta sesión, ordenadas.\n *\n * @param {Record<string, any>|any[]} menuModules lo que regresa import.meta.glob(..., {eager: true}) o una lista\n * @param {object} [options]\n * @param {(access: object|undefined) => boolean} [options.canAccess] la regla de permisos del proyecto; sin ella, todos\n * @param {object} [options.context] lo que reciben buildMenuItem(s): la sesión, la configuración…\n * @returns {object[]} las entradas, cada una con to y su texto\n */\nexport function composeMenu(menuModules, {canAccess = () => true, context = {}} = {}) {\n    const modules = Array.isArray(menuModules) ? menuModules : Object.values(menuModules);\n    return modules\n        .filter((menuModule) => canAccess(menuModule.access))\n        .sort((first, second) => (first.order ?? LAST_ORDER) - (second.order ?? LAST_ORDER))\n        .flatMap((menuModule) => menuModule.buildMenuItems?.(context) ?? [menuModule.buildMenuItem?.(context)])\n        .filter((menuItem) => Boolean(menuItem) && canAccess(menuItem.access))\n        .map((menuItem) => withAllowedChildren(menuItem, canAccess))\n        .filter((menuItem) => Boolean(menuItem.to) || menuItem.children?.length > 0);\n}\n\n/**\n * La entrada con solo las hijas que la sesión puede ver (una entrada sin submenú se queda igual).\n *\n * @param {object} menuItem\n * @param {(access: object|undefined) => boolean} canAccess\n * @returns {object}\n */\nfunction withAllowedChildren(menuItem, canAccess) {\n    if (!Array.isArray(menuItem.children)) {\n        return menuItem;\n    }\n    return {...menuItem, children: menuItem.children.filter((child) => Boolean(child) && canAccess(child.access))};\n}\n\n/**\n * Las entradas que llevan a una pantalla, con las de los submenús (las de arriba primero).\n *\n * @param {object[]} menuItems lo que regresa composeMenu\n * @returns {object[]}\n */\nexport function screenMenuItemsOf(menuItems) {\n    return menuItems.flatMap((menuItem) => [menuItem, ...(menuItem.children ?? [])]).filter((menuItem) => Boolean(menuItem.to));\n}\n\n/**\n * ¿Está la entrada dentro de un submenú?\n *\n * @param {object[]} menuItems\n * @param {object} menuItem\n * @returns {boolean}\n */\nfunction isChildMenuItem(menuItems, menuItem) {\n    return menuItems.some((candidate) => candidate.children?.includes(menuItem));\n}\n\n/**\n * La entrada del menú de la pantalla abierta: la más específica gana (/orders/15 marca «Pedidos», no «Inicio»).\n *\n * @param {Array<{to: string, matchPrefix?: string}>} menuItems lo que regresa composeMenu\n * @param {string} pathname location.pathname\n * @returns {object|null}\n */\nexport function activeMenuItemOf(menuItems, pathname) {\n    const matchingItems = screenMenuItemsOf(menuItems).filter((menuItem) => {\n        const prefix = menuItem.matchPrefix ?? menuItem.to;\n        // el inicio solo se marca en el inicio: todas las direcciones empiezan con '/'\n        const isHome = prefix === HOME_PATH;\n        return pathname === prefix || (!isHome && pathname.startsWith(`${prefix}/`));\n    });\n    matchingItems.sort((first, second) => {\n        const lengthDifference = (second.matchPrefix ?? second.to).length - (first.matchPrefix ?? first.to).length;\n        if (lengthDifference !== 0) {\n            return lengthDifference;\n        }\n        // con el mismo camino (un submenú cuya primera hija lleva a donde mismo que él), gana la hija: es la pantalla\n        return Number(isChildMenuItem(menuItems, second)) - Number(isChildMenuItem(menuItems, first));\n    });\n    return matchingItems[0] ?? null;\n}\n\n/**\n * El submenú que contiene a una entrada (para abrirlo y para las migas); null si la entrada está arriba.\n *\n * @param {object[]} menuItems lo que regresa composeMenu\n * @param {object|null} menuItem\n * @returns {object|null}\n */\nexport function parentMenuItemOf(menuItems, menuItem) {\n    return menuItems.find((candidate) => candidate.children?.includes(menuItem)) ?? null;\n}\n\n/**\n * Las migas de la pantalla abierta, sacadas del menú: el inicio, el submenú (si lo hay) y la entrada activa.\n * En el inicio, o en una pantalla que no está en el menú, regresa solo lo que encuentra (una o ninguna).\n *\n * @param {object[]} menuItems lo que regresa composeMenu\n * @param {string} pathname location.pathname\n * @returns {object[]} entradas del menú, en orden\n */\nexport function menuBreadcrumbsOf(menuItems, pathname) {\n    const activeItem = activeMenuItemOf(menuItems, pathname);\n    if (!activeItem) {\n        return [];\n    }\n    const homeItem = menuItems.find((menuItem) => menuItem.to === HOME_PATH) ?? null;\n    const parentItem = parentMenuItemOf(menuItems, activeItem);\n    return [homeItem, parentItem, activeItem].filter((menuItem, index, crumbs) => Boolean(menuItem) && crumbs.indexOf(menuItem) === index);\n}\n\n/**\n * El badge de una entrada del menú: el conteo que llegó del servidor por su badgeKey (lo pendiente de esa pantalla), la\n * suma de sus hijas si es un submenú (como las carpetas del iPhone), o el badge fijo de su menu.js («Nuevo»). Un conteo\n * en cero no se enseña: no hay nada pendiente.\n *\n *   menuBadgeOf({badgeKey: 'pendingPayment'}, {pendingPayment: 13})   // {content: 13, isCount: true}\n *\n * @param {object} menuItem una entrada de composeMenu\n * @param {Record<string, number>} [menuBadges] los conteos por badgeKey (el proyecto los pide a su servidor)\n * @returns {{content: number|string, isCount: boolean}|null}\n */\nexport function menuBadgeOf(menuItem, menuBadges = {}) {\n    const countOf = (item) => {\n        const count = item.badgeKey ? Number(menuBadges[item.badgeKey] ?? 0) : 0;\n        return Number.isFinite(count) && count > 0 ? count : 0;\n    };\n    const ownCount = countOf(menuItem);\n    const childrenCount = Array.isArray(menuItem.children) ? menuItem.children.reduce((total, child) => total + countOf(child), 0) : 0;\n    const total = ownCount + childrenCount;\n    if (total > 0) {\n        return {content: total, isCount: true};\n    }\n    if (menuItem.badge !== undefined && menuItem.badge !== null && menuItem.badge !== '') {\n        return {content: menuItem.badge, isCount: typeof menuItem.badge === 'number'};\n    }\n    return null;\n}\n\n// cuántas pestañas van en la barra del teléfono si no se dice otra cosa, como las de Apple: hasta 5; si hay más entradas,\n// 4 y «Más» con el resto. La barra (MobileTabBar) pasa las que de verdad caben a lo ancho\nconst MOBILE_TAB_LIMIT = 5;\n/** Cuántas puede fijar la persona en la barra: las que caben junto a «Más». */\nexport const PINNABLE_TAB_LIMIT = MOBILE_TAB_LIMIT - 1;\n\n/**\n * Con qué se reconoce una entrada del menú para recordarla (las pestañas que fijó la persona): su ruta, o su llave de\n * texto si no navega. No el texto traducido: cambia con el idioma.\n *\n * @param {{to?: string, labelKey?: string, label?: string}} menuItem\n * @returns {string}\n */\nexport function menuItemKeyOf(menuItem) {\n    return menuItem.to ?? menuItem.labelKey ?? menuItem.label;\n}\n\n/**\n * Las pestañas de la barra del teléfono y lo que va en «Más». Van las que fijó la persona (pinnedKeys, en el orden del\n * menú); si no fijó ninguna, las que el menu.js marca con mobileTab: true; si ninguna lo dice, las primeras. Si todas\n * las entradas caben (tabLimit), van todas y no hay «Más»; si no, tabLimit - 1 y «Más» con el resto.\n *\n * @param {object[]} menuItems lo que regresa composeMenu\n * @param {string[]|null} [pinnedKeys] las que eligió la persona (menuItemKeyOf); las que ya no existen o ya no puede ver\n *     no cuentan\n * @param {number} [tabLimit] cuántas caben en la barra contando «Más» (por omisión 5; la barra mide su ancho)\n * @returns {{tabs: object[], more: object[]}}\n */\nexport function mobileTabsOf(menuItems, pinnedKeys = null, tabLimit = MOBILE_TAB_LIMIT) {\n    if (menuItems.length <= tabLimit) {\n        return {tabs: menuItems, more: []};\n    }\n    const pinned = menuItems.filter((menuItem) => (pinnedKeys ?? []).includes(menuItemKeyOf(menuItem)));\n    const marked = menuItems.filter((menuItem) => menuItem.mobileTab);\n    let candidates = menuItems;\n    if (pinned.length > 0) {\n        candidates = pinned;\n    } else if (marked.length > 0) {\n        candidates = marked;\n    }\n    // una de las que caben es para «Más»\n    const tabs = candidates.slice(0, Math.max(tabLimit - 1, 1));\n    return {tabs, more: menuItems.filter((menuItem) => !tabs.includes(menuItem))};\n}\n"],"names":["total"],"mappings":"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"}

package/dist/navigation/useMenuBadges.js

@@ -0,0 +1,45 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from "react";
+function menuBadgesFrom(response) {
+  const isCount = (count) => count !== null && count !== void 0 && count !== "" && Number.isFinite(Number(count));
+  const list = Array.isArray(response) ? response : Array.isArray(response?.badges) ? response.badges : null;
+  if (list) {
+    return Object.fromEntries(list.filter((item) => item?.badgeKey && isCount(item.count)).map((item) => [item.badgeKey, Number(item.count)]));
+  }
+  if (response && typeof response === "object") {
+    return Object.fromEntries(Object.entries(response).filter(([, count]) => isCount(count)).map(([key, count]) => [key, Number(count)]));
+  }
+  return {};
+}
+function useMenuBadges(loadBadges) {
+  const [menuBadges, setMenuBadges] = useState({});
+  const [isLoading, setIsLoading] = useState(false);
+  const inflight = useRef(null);
+  const loadRef = useRef(loadBadges);
+  loadRef.current = loadBadges;
+  const refreshMenuBadges = useCallback(() => {
+    if (inflight.current) {
+      return inflight.current;
+    }
+    setIsLoading(true);
+    inflight.current = (async () => {
+      try {
+        setMenuBadges(menuBadgesFrom(await loadRef.current()));
+      } catch {
+      } finally {
+        setIsLoading(false);
+        inflight.current = null;
+      }
+    })();
+    return inflight.current;
+  }, []);
+  useEffect(() => {
+    refreshMenuBadges();
+  }, [refreshMenuBadges]);
+  return { menuBadges, refreshMenuBadges, isLoading };
+}
+export {
+  menuBadgesFrom,
+  useMenuBadges
+};
+//# sourceMappingURL=useMenuBadges.js.map

package/dist/navigation/useMenuBadges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMenuBadges.js","sources":["../../src/navigation/useMenuBadges.js"],"sourcesContent":["// Los conteos de los badges del menú (lo pendiente de cada pantalla), pedidos al servidor del proyecto: AppLayout los pinta\n// por el badgeKey de cada entrada (navigation/appMenu.js, menuBadgeOf).\n//\n//   const {menuBadges, refreshMenuBadges} = useMenuBadges(() => api.get('/users/badges'));\n//   <AppLayout menuBadges={menuBadges} …>\n//\n// El servidor puede contestar una lista [{badgeKey, count}] o un objeto {badgeKey: count}: los dos se aceptan.\n// refreshMenuBadges() los vuelve a pedir (después de aprobar o rechazar algo); si se llama varias veces seguidas, se pide\n// una sola vez: las demás esperan la misma respuesta. Si la petición falla, se quedan los conteos de antes (un badge viejo\n// es mejor que un menú que truena).\n//\n// Genérico del paquete: function (regla de la casa).\nimport {useCallback, useEffect, useRef, useState} from 'react';\n\n/**\n * La respuesta del servidor como {badgeKey: conteo}.\n *\n * @param {unknown} response\n * @returns {Record<string, number>}\n */\nexport function menuBadgesFrom(response) {\n    // OJO: Number(null) es 0 y pasaría como conteo: lo que llega vacío no es un número\n    const isCount = (count) => count !== null && count !== undefined && count !== '' && Number.isFinite(Number(count));\n    const list = Array.isArray(response) ? response : (Array.isArray(response?.badges) ? response.badges : null);\n    if (list) {\n        return Object.fromEntries(list\n            .filter((item) => item?.badgeKey && isCount(item.count))\n            .map((item) => [item.badgeKey, Number(item.count)]));\n    }\n    if (response && typeof response === 'object') {\n        return Object.fromEntries(Object.entries(response).filter(([, count]) => isCount(count)).map(([key, count]) => [key, Number(count)]));\n    }\n    return {};\n}\n\n/**\n * @param {() => Promise<unknown>} loadBadges pide los conteos al servidor\n * @returns {{menuBadges: Record<string, number>, refreshMenuBadges: () => Promise<void>, isLoading: boolean}}\n */\nexport function useMenuBadges(loadBadges) {\n    const [menuBadges, setMenuBadges] = useState({});\n    const [isLoading, setIsLoading] = useState(false);\n    // la petición en curso: si ya hay una, las demás llamadas esperan esa\n    const inflight = useRef(null);\n    // la función más reciente del proyecto, sin volver a pedir cada que se pinta\n    const loadRef = useRef(loadBadges);\n    loadRef.current = loadBadges;\n\n    const refreshMenuBadges = useCallback(() => {\n        if (inflight.current) {\n            return inflight.current;\n        }\n        setIsLoading(true);\n        inflight.current = (async () => {\n            try {\n                setMenuBadges(menuBadgesFrom(await loadRef.current()));\n            } catch {\n                // se quedan los conteos de antes\n            } finally {\n                setIsLoading(false);\n                inflight.current = null;\n            }\n        })();\n        return inflight.current;\n    }, []);\n\n    useEffect(() => {\n        refreshMenuBadges();\n    }, [refreshMenuBadges]);\n\n    return {menuBadges, refreshMenuBadges, isLoading};\n}\n"],"names":[],"mappings":";;AAoBO,SAAS,eAAe,UAAU;AAErC,QAAM,UAAU,CAAC,UAAU,UAAU,QAAQ,UAAU,UAAa,UAAU,MAAM,OAAO,SAAS,OAAO,KAAK,CAAC;AACjH,QAAM,OAAO,MAAM,QAAQ,QAAQ,IAAI,WAAY,MAAM,QAAQ,UAAU,MAAM,IAAI,SAAS,SAAS;AACvG,MAAI,MAAM;AACN,WAAO,OAAO,YAAY,KACrB,OAAO,CAAC,SAAS,MAAM,YAAY,QAAQ,KAAK,KAAK,CAAC,EACtD,IAAI,CAAC,SAAS,CAAC,KAAK,UAAU,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC;AAAA,EAC3D;AACA,MAAI,YAAY,OAAO,aAAa,UAAU;AAC1C,WAAO,OAAO,YAAY,OAAO,QAAQ,QAAQ,EAAE,OAAO,CAAC,GAAG,KAAK,MAAM,QAAQ,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC,CAAC;AAAA,EACxI;AACA,SAAO,CAAA;AACX;AAMO,SAAS,cAAc,YAAY;AACtC,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,CAAA,CAAE;AAC/C,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAEhD,QAAM,WAAW,OAAO,IAAI;AAE5B,QAAM,UAAU,OAAO,UAAU;AACjC,UAAQ,UAAU;AAElB,QAAM,oBAAoB,YAAY,MAAM;AACxC,QAAI,SAAS,SAAS;AAClB,aAAO,SAAS;AAAA,IACpB;AACA,iBAAa,IAAI;AACjB,aAAS,WAAW,YAAY;AAC5B,UAAI;AACA,sBAAc,eAAe,MAAM,QAAQ,QAAO,CAAE,CAAC;AAAA,MACzD,QAAQ;AAAA,MAER,UAAC;AACG,qBAAa,KAAK;AAClB,iBAAS,UAAU;AAAA,MACvB;AAAA,IACJ,GAAC;AACD,WAAO,SAAS;AAAA,EACpB,GAAG,CAAA,CAAE;AAEL,YAAU,MAAM;AACZ,sBAAiB;AAAA,EACrB,GAAG,CAAC,iBAAiB,CAAC;AAEtB,SAAO,EAAC,YAAY,mBAAmB,UAAS;AACpD;"}