@grupolapa/desarrollos-sdk 0.1.0

package/dist/calculate-quote.js

@@ -0,0 +1,382 @@
+import { getFinanceRulesRentalRateForUnit, getUnitEstimatedRentalAnnualMXN, getUnitEstimatedRentalMonthlyMXN, getUnitDeliveryMonths, getUnitListPriceMXN, isCashbackScheme, isInstallmentScheme, MAX_CASHBACK_MONTHS, } from "./payment-schemes.js";
+import { getInstallmentAllocation, getInstallmentDiscountPct, INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT, INSTALLMENT_DEFAULT_MONTHLY_PCT, } from "./installment-allocation.js";
+import { getEscalatedAnnualAmountMXN, isCorporateRentalUnit, } from "./corporate-rent.js";
+import { applyIvaModeMXN } from "./tax.js";
+function getVisibleTimelineRows(rows, deferredPaymentMonths, deliveryMonths, isCashback, cashbackMonths) {
+    const visibleMonths = new Set([
+        0,
+        1,
+        2,
+        3,
+        Math.round(deliveryMonths / 2),
+        deliveryMonths,
+    ]);
+    for (let year = 1; year <= Math.ceil(deliveryMonths / 12); year += 1) {
+        visibleMonths.add(year * 12);
+    }
+    if (isCashback) {
+        visibleMonths.add(cashbackMonths);
+    }
+    else {
+        deferredPaymentMonths.forEach((month) => visibleMonths.add(month));
+    }
+    return [...visibleMonths]
+        .filter((month) => month >= 0 && month <= deliveryMonths)
+        .sort((left, right) => left - right)
+        .map((month) => rows[month]);
+}
+export function calculateQuote(unit, input, scheme, rules) {
+    const listPriceMXN = applyIvaModeMXN(getUnitListPriceMXN(unit), input.includeIva);
+    const plusvaliaRate = input.plusvaliaAnnualPct / 100;
+    const plusvaliaMonthlyRate = plusvaliaRate / 12;
+    const deliveryMonths = getUnitDeliveryMonths(unit);
+    const isCashback = isCashbackScheme(scheme);
+    const cashbackMonths = isCashback
+        ? Math.min(deliveryMonths, MAX_CASHBACK_MONTHS)
+        : 0;
+    const isCashbackCapped = isCashback && cashbackMonths < deliveryMonths;
+    const installmentAllocation = isInstallmentScheme(scheme)
+        ? getInstallmentAllocation(input.installmentDownPaymentPct ?? INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT, input.installmentMonthlyPct ?? INSTALLMENT_DEFAULT_MONTHLY_PCT)
+        : null;
+    const downPaymentPct = isCashback
+        ? input.downPaymentPct
+        : (installmentAllocation?.downPaymentPct ?? 0);
+    const downPaymentAmountMXN = listPriceMXN * (downPaymentPct / 100);
+    const balanceAmountMXN = listPriceMXN - downPaymentAmountMXN;
+    const cashbackMonthlyMXN = isCashback
+        ? (downPaymentAmountMXN * scheme.cashbackRate) / 12
+        : 0;
+    const cashbackTotalMXN = cashbackMonthlyMXN * cashbackMonths;
+    const rawMonthlyPaymentPct = installmentAllocation?.monthlyPct ?? 0;
+    const rawDeferredPaymentPct = installmentAllocation?.deferredPct ?? 0;
+    const preDeliveryPaymentMonths = Math.max(deliveryMonths - 1, 0);
+    const deferredPaymentsCount = installmentAllocation && rawDeferredPaymentPct > 0
+        ? Math.floor(preDeliveryPaymentMonths / 12)
+        : 0;
+    const deferredPaymentMonths = Array.from({ length: deferredPaymentsCount }, (_, index) => (index + 1) * 12);
+    const deferredPaymentMonthSet = new Set(deferredPaymentMonths);
+    const monthlyPaymentMonths = installmentAllocation && rawMonthlyPaymentPct > 0
+        ? Array.from({ length: preDeliveryPaymentMonths }, (_, index) => index + 1).filter((month) => !deferredPaymentMonthSet.has(month))
+        : [];
+    const monthlyPaymentCount = monthlyPaymentMonths.length;
+    const monthlyPaymentMonthSet = new Set(monthlyPaymentMonths);
+    const monthlyPaymentPct = monthlyPaymentCount > 0 ? rawMonthlyPaymentPct : 0;
+    const monthlyPctRolledToDelivery = rawMonthlyPaymentPct - monthlyPaymentPct;
+    const monthlyPaymentTotalMXN = listPriceMXN * (monthlyPaymentPct / 100);
+    const monthlyPaymentAmountMXN = monthlyPaymentCount > 0 ? monthlyPaymentTotalMXN / monthlyPaymentCount : 0;
+    const deferredPaymentPct = deferredPaymentsCount > 0 ? rawDeferredPaymentPct : 0;
+    const deferredPctRolledToDelivery = rawDeferredPaymentPct - deferredPaymentPct;
+    const deferredPaymentsTotalMXN = listPriceMXN * (deferredPaymentPct / 100);
+    const deferredPaymentAmountMXN = deferredPaymentsCount > 0
+        ? deferredPaymentsTotalMXN / deferredPaymentsCount
+        : 0;
+    const deliveryPaymentPct = installmentAllocation
+        ? installmentAllocation.deliveryPct +
+            monthlyPctRolledToDelivery +
+            deferredPctRolledToDelivery
+        : 100 - downPaymentPct;
+    const deliveryPaymentAmountMXN = installmentAllocation
+        ? listPriceMXN * (deliveryPaymentPct / 100)
+        : balanceAmountMXN;
+    const installmentDiscountPct = installmentAllocation
+        ? getInstallmentDiscountPct(installmentAllocation.downPaymentPct)
+        : 0;
+    const installmentDiscountMXN = listPriceMXN * (installmentDiscountPct / 100);
+    let installmentDiscountRemainingMXN = installmentDiscountMXN;
+    const deliveryDiscountMXN = Math.min(deliveryPaymentAmountMXN, installmentDiscountRemainingMXN);
+    installmentDiscountRemainingMXN -= deliveryDiscountMXN;
+    const adjustedDeliveryAmountMXN = deliveryPaymentAmountMXN - deliveryDiscountMXN;
+    const deferredDiscountMXN = Math.min(deferredPaymentsTotalMXN, installmentDiscountRemainingMXN);
+    installmentDiscountRemainingMXN -= deferredDiscountMXN;
+    const adjustedDeferredTotalMXN = deferredPaymentsTotalMXN - deferredDiscountMXN;
+    const adjustedDeferredAmountMXN = deferredPaymentsCount > 0
+        ? adjustedDeferredTotalMXN / deferredPaymentsCount
+        : 0;
+    const monthlyTotalGrossMXN = monthlyPaymentAmountMXN * monthlyPaymentCount;
+    const monthlyDiscountMXN = Math.min(monthlyTotalGrossMXN, installmentDiscountRemainingMXN);
+    const adjustedMonthlyTotalMXN = monthlyTotalGrossMXN - monthlyDiscountMXN;
+    const adjustedMonthlyAmountMXN = monthlyPaymentCount > 0 ? adjustedMonthlyTotalMXN / monthlyPaymentCount : 0;
+    const milestones = {};
+    if (isCashback) {
+        milestones[1] = rules.milestones.cashbackStart;
+        milestones[Math.round(deliveryMonths / 2)] = rules.milestones.midpoint;
+        if (isCashbackCapped) {
+            milestones[cashbackMonths] = "Último cashback";
+        }
+        milestones[deliveryMonths] = rules.milestones.delivery;
+    }
+    else {
+        deferredPaymentMonths.forEach((month) => {
+            milestones[month] =
+                `${rules.milestones.annualityPrefix} ${deferredPaymentAmountMXN.toLocaleString("es-MX", {
+                    style: "currency",
+                    currency: "MXN",
+                    maximumFractionDigits: 0,
+                })}`;
+        });
+        milestones[deliveryMonths] = rules.milestones.delivery;
+    }
+    const timelineRows = [
+        {
+            month: 0,
+            paymentMXN: downPaymentAmountMXN,
+            paymentLabel: "Enganche",
+            cashbackMXN: 0,
+            plusvaliaDeltaMXN: 0,
+            accumulatedCashbackMXN: 0,
+            accumulatedPlusvaliaMXN: 0,
+            assetValueMXN: listPriceMXN,
+            isMilestone: true,
+            milestoneLabel: "Enganche",
+        },
+    ];
+    let previousAssetValueMXN = listPriceMXN;
+    let accumulatedCashbackMXN = 0;
+    let accumulatedPlusvaliaMXN = 0;
+    for (let month = 1; month <= deliveryMonths; month += 1) {
+        const assetValueMXN = listPriceMXN * Math.pow(1 + plusvaliaMonthlyRate, month);
+        const plusvaliaDeltaMXN = assetValueMXN - previousAssetValueMXN;
+        accumulatedPlusvaliaMXN += plusvaliaDeltaMXN;
+        const cashbackForMonthMXN = isCashback && month <= cashbackMonths ? cashbackMonthlyMXN : 0;
+        let paymentMXN = 0;
+        let paymentLabel = "—";
+        if (isCashback) {
+            if (month === deliveryMonths) {
+                paymentMXN = balanceAmountMXN;
+                paymentLabel = "Saldo contra entrega";
+            }
+        }
+        else if (installmentAllocation) {
+            const hasMonthlyPaymentForMonth = monthlyPaymentPct > 0 && monthlyPaymentMonthSet.has(month);
+            const hasDeferredPaymentForMonth = deferredPaymentMonthSet.has(month);
+            if (hasMonthlyPaymentForMonth) {
+                paymentMXN += adjustedMonthlyAmountMXN;
+                paymentLabel = "Mensualidad";
+            }
+            if (hasDeferredPaymentForMonth) {
+                paymentMXN += adjustedDeferredAmountMXN;
+                paymentLabel = "Anualidad";
+            }
+            if (month === deliveryMonths && adjustedDeliveryAmountMXN > 0) {
+                paymentMXN += adjustedDeliveryAmountMXN;
+                paymentLabel = `Contra entrega ${deliveryPaymentPct}%`;
+            }
+        }
+        accumulatedCashbackMXN += cashbackForMonthMXN;
+        timelineRows.push({
+            month,
+            paymentMXN,
+            paymentLabel,
+            cashbackMXN: cashbackForMonthMXN,
+            plusvaliaDeltaMXN,
+            accumulatedCashbackMXN,
+            accumulatedPlusvaliaMXN,
+            assetValueMXN,
+            isMilestone: Boolean(milestones[month]),
+            milestoneLabel: milestones[month] ?? "",
+        });
+        previousAssetValueMXN = assetValueMXN;
+    }
+    const finalTimelineRow = timelineRows.at(-1);
+    if (!finalTimelineRow) {
+        throw new Error("Unable to build the quote timeline.");
+    }
+    const projectionPoints = [
+        {
+            yearOffset: 0,
+            label: "Entrega",
+            assetValueMXN: finalTimelineRow.assetValueMXN,
+            rentalAccumulatedMXN: 0,
+            valueWithRentMXN: finalTimelineRow.assetValueMXN,
+        },
+    ];
+    let projectedAssetValueMXN = finalTimelineRow.assetValueMXN;
+    let rentalAccumulatedMXN = 0;
+    const rentalRate = getFinanceRulesRentalRateForUnit(unit, rules);
+    const baseRentalAnnualMXN = getUnitEstimatedRentalAnnualMXN(unit, rentalRate, input.includeIva);
+    const usesCorporateRentalInflation = isCorporateRentalUnit(unit);
+    for (let year = 1; year <= input.postDeliveryYears; year += 1) {
+        projectedAssetValueMXN *= 1 + plusvaliaRate;
+        rentalAccumulatedMXN += usesCorporateRentalInflation
+            ? getEscalatedAnnualAmountMXN(baseRentalAnnualMXN, rules.corporateInflationRate, year)
+            : projectedAssetValueMXN * rentalRate;
+        projectionPoints.push({
+            yearOffset: year,
+            label: `Año +${year}`,
+            assetValueMXN: projectedAssetValueMXN,
+            rentalAccumulatedMXN,
+            valueWithRentMXN: projectedAssetValueMXN + rentalAccumulatedMXN,
+        });
+    }
+    const netCostMXN = isCashback
+        ? listPriceMXN - cashbackTotalMXN
+        : listPriceMXN - installmentDiscountMXN;
+    const plusvaliaAtDeliveryMXN = finalTimelineRow.accumulatedPlusvaliaMXN;
+    const plusvaliaPostDeliveryMXN = projectedAssetValueMXN - finalTimelineRow.assetValueMXN;
+    const totalGainMXN = plusvaliaAtDeliveryMXN +
+        plusvaliaPostDeliveryMXN +
+        cashbackTotalMXN +
+        installmentDiscountMXN +
+        rentalAccumulatedMXN;
+    const cashbackTotalLabel = isCashbackCapped
+        ? `Cashback total recibido (${cashbackMonths} meses)`
+        : "Cashback total recibido";
+    const costBreakdown = isCashback
+        ? [
+            {
+                label: `Enganche (${downPaymentPct}%)`,
+                valueMXN: -downPaymentAmountMXN,
+                tone: "negative",
+            },
+            {
+                label: `Saldo contra entrega (${100 - downPaymentPct}%)`,
+                valueMXN: -balanceAmountMXN,
+                tone: "negative",
+            },
+            {
+                label: cashbackTotalLabel,
+                valueMXN: cashbackTotalMXN,
+                tone: "auric",
+            },
+            {
+                label: "Costo neto",
+                valueMXN: -netCostMXN,
+                tone: "neutral",
+            },
+        ]
+        : installmentAllocation
+            ? [
+                {
+                    label: `Enganche inicial (${installmentAllocation.downPaymentPct}%)`,
+                    valueMXN: -downPaymentAmountMXN,
+                    tone: "negative",
+                },
+                ...(monthlyPaymentPct > 0
+                    ? [
+                        {
+                            label: `Mensualidades (${monthlyPaymentPct}%)`,
+                            valueMXN: -monthlyPaymentTotalMXN,
+                            tone: "negative",
+                        },
+                    ]
+                    : []),
+                ...(deferredPaymentPct > 0
+                    ? [
+                        {
+                            label: `Anualidades diferidas (${deferredPaymentPct}%)`,
+                            valueMXN: -deferredPaymentsTotalMXN,
+                            tone: "negative",
+                        },
+                    ]
+                    : []),
+                ...(deliveryPaymentPct > 0
+                    ? [
+                        {
+                            label: `Contra entrega (${deliveryPaymentPct}%)`,
+                            valueMXN: -deliveryPaymentAmountMXN,
+                            tone: "negative",
+                        },
+                    ]
+                    : []),
+                ...(installmentDiscountMXN > 0
+                    ? [
+                        {
+                            label: `Descuento por enganche (${installmentDiscountPct}%)`,
+                            valueMXN: installmentDiscountMXN,
+                            tone: "auric",
+                        },
+                    ]
+                    : []),
+                {
+                    label: "Total invertido",
+                    valueMXN: -netCostMXN,
+                    tone: "neutral",
+                },
+            ]
+            : [];
+    const gainBreakdown = [
+        {
+            label: "Plusvalía acumulada al escriturar",
+            valueMXN: plusvaliaAtDeliveryMXN,
+            tone: "positive",
+        },
+        {
+            label: "Plusvalía posterior a la escritura",
+            valueMXN: plusvaliaPostDeliveryMXN,
+            tone: "positive",
+        },
+        ...(isCashback
+            ? [
+                {
+                    label: cashbackTotalLabel,
+                    valueMXN: cashbackTotalMXN,
+                    tone: "auric",
+                },
+            ]
+            : []),
+        ...(!isCashback && installmentDiscountMXN > 0
+            ? [
+                {
+                    label: `Descuento por enganche (${installmentDiscountPct}%)`,
+                    valueMXN: installmentDiscountMXN,
+                    tone: "auric",
+                },
+            ]
+            : []),
+        {
+            label: "Valor proyectado del activo",
+            valueMXN: projectedAssetValueMXN,
+            tone: "neutral",
+        },
+        {
+            label: "Renta acumulada proyectada",
+            valueMXN: rentalAccumulatedMXN,
+            tone: "positive",
+        },
+        {
+            label: "Ganancia total estimada",
+            valueMXN: totalGainMXN,
+            tone: "positive",
+        },
+    ];
+    return {
+        unit,
+        scheme,
+        input,
+        listPriceMXN,
+        deliveryMonths,
+        isCashback,
+        cashbackMonths,
+        isCashbackCapped,
+        downPaymentPct,
+        downPaymentAmountMXN,
+        balanceAmountMXN,
+        cashbackMonthlyMXN,
+        cashbackTotalMXN,
+        installmentDiscountPct,
+        installmentDiscountMXN,
+        monthlyPaymentPct,
+        monthlyPaymentCount,
+        monthlyPaymentAmountMXN,
+        deferredPaymentPct,
+        deferredPaymentsTotalMXN,
+        deferredPaymentsCount,
+        deferredPaymentMonths,
+        deferredPaymentAmountMXN,
+        deliveryPaymentPct,
+        deliveryPaymentAmountMXN,
+        netCostMXN,
+        plusvaliaAtDeliveryMXN,
+        plusvaliaPostDeliveryMXN,
+        totalGainMXN,
+        finalAssetValueMXN: finalTimelineRow.assetValueMXN,
+        projectedAssetValueMXN,
+        rentalMonthlyMXN: getUnitEstimatedRentalMonthlyMXN(unit, rentalRate, input.includeIva),
+        rentalAccumulatedMXN,
+        projectionPoints,
+        timelineRows,
+        visibleTimelineRows: getVisibleTimelineRows(timelineRows, deferredPaymentMonths, deliveryMonths, isCashback, cashbackMonths),
+        costBreakdown,
+        gainBreakdown,
+    };
+}

package/dist/corporate-actions.d.ts

@@ -0,0 +1,95 @@
+import { buildCorporatePlan, type EntradaActionSchemeId } from "./entrada.js";
+import type { AppContent, InventoryAvailabilityByUnitId, InventoryUnit } from "./types.js";
+export declare const CORPORATE_ACTION_MIN_COUNT = 1;
+export declare const CORPORATE_ACTION_MAX_COUNT = 5;
+export declare const CORPORATE_ACTION_DEFAULT_SCHEME_ID: "contado";
+export declare const CORPORATE_ACTION_MIN_ENGANCHE_SCHEME_ID = "amplio";
+export type CorporateActionPlan = ReturnType<typeof buildCorporatePlan>;
+export declare function isCorporateActionUnit(unit: InventoryUnit | null | undefined, content: AppContent): boolean;
+export declare function getCorporateActionTotalShares({ availabilityByUnitId, content, unit, }: {
+    availabilityByUnitId: InventoryAvailabilityByUnitId;
+    content: AppContent;
+    unit: InventoryUnit;
+}): number;
+export declare function clampCorporateActionCount(value: number): number;
+export declare function parseCorporateActionCount(value: string | undefined): number;
+export declare function normalizeCorporateActionSchemeId(value: string | null | undefined): EntradaActionSchemeId;
+export declare function buildCorporateActionPlan({ actionCount, availabilityByUnitId, content, schemeId, unit, }: {
+    actionCount: number;
+    availabilityByUnitId: InventoryAvailabilityByUnitId;
+    content: AppContent;
+    schemeId: EntradaActionSchemeId | string | null | undefined;
+    unit: InventoryUnit;
+}): {
+    capitalMXN: number;
+    engancheMXN: number;
+    m2: number;
+    monthlyCount: 0 | 5 | 13;
+    monthlyPaymentMXN: number;
+    numActions: number;
+    operationMonthlyReturnMXN: number;
+    operationAnnualReturnNetMXN: number;
+    operationMonthlyReturnNetMXN: number;
+    operationReturnHorizonNetMXN: number;
+    obraReturnMonthlyMXN: number;
+    obraReturnMonthlyNetMXN: number;
+    obraReturnNetMXN: number;
+    patrimonioTotalMXN: number;
+    plusvaliaGainMXN: number;
+    pricePerActionMXN: number;
+    projectedAssetValueMXN: number;
+    scheme: {
+        readonly id: "contado";
+        readonly description: "Liquidas tu acción en una sola exhibición y accedes a tasa preferencial desde el mes 1.";
+        readonly engancheRatio: 1;
+        readonly label: "Contado";
+        readonly monthlyCount: 0;
+        readonly monthlyRatio: 0;
+        readonly tag: "Máximo rendimiento";
+        readonly tasaObra: 0.08;
+        readonly tasaObraLabel: "8%";
+    } | {
+        readonly id: "medio";
+        readonly description: "Enganche de $120K y 5 mensualidades de $40K. Rendimiento del 6% anual una vez liquidado el capital.";
+        readonly engancheRatio: number;
+        readonly label: "Financiado 5 meses";
+        readonly monthlyCount: 5;
+        readonly monthlyRatio: number;
+        readonly tag: "Balance";
+        readonly tasaObra: 0.06;
+        readonly tasaObraLabel: "6%";
+    } | {
+        readonly id: "amplio";
+        readonly description: "Enganche de $60K y 13 mensualidades de $20K. Rendimiento del 4% anual una vez liquidado el capital.";
+        readonly engancheRatio: number;
+        readonly label: "Financiado 13 meses";
+        readonly monthlyCount: 13;
+        readonly monthlyRatio: number;
+        readonly tag: "Más accesible";
+        readonly tasaObra: 0.04;
+        readonly tasaObraLabel: "4%";
+    };
+    totalMonths: 0 | 5 | 13;
+    totalPaidMXN: number;
+};
+export declare function getCorporateActionUnitDisplay({ availabilityByUnitId, content, unit, }: {
+    availabilityByUnitId: InventoryAvailabilityByUnitId;
+    content: AppContent;
+    unit: InventoryUnit;
+}): {
+    m2PerAction: number;
+    monthlyRentPerActionMXN: number;
+    pricePerActionMXN: number;
+    totalShares: number;
+};
+export declare function buildCorporateActionProductLabel(plan: CorporateActionPlan): string;
+export declare function buildCorporateActionCheckoutSelection(plan: CorporateActionPlan): {
+    capitalMXN: number;
+    engancheMXN: number;
+    m2: number;
+    monthlyPaymentMXN: number;
+    numActions: number;
+    operationMonthlyReturnNetMXN: number;
+    pricePerActionMXN: number;
+    schemeId: "contado" | "medio" | "amplio";
+};

package/dist/corporate-actions.js

@@ -0,0 +1,87 @@
+import { isCorporateRentalUnit } from "./corporate-rent.js";
+import { buildCorporatePlan, ENTRADA_ACTION_SCHEMES, getCorporateM2PerAction, getCorporatePricePerActionMXN, } from "./entrada.js";
+import { getInventoryAvailability } from "./inventory-availability.js";
+export const CORPORATE_ACTION_MIN_COUNT = 1;
+export const CORPORATE_ACTION_MAX_COUNT = 5;
+export const CORPORATE_ACTION_DEFAULT_SCHEME_ID = ENTRADA_ACTION_SCHEMES[0].id;
+export const CORPORATE_ACTION_MIN_ENGANCHE_SCHEME_ID = "amplio";
+function getProductTypeForUnit(content, unit) {
+    return (content.productTypes.find((productType) => productType.id === unit.productTypeId) ?? null);
+}
+export function isCorporateActionUnit(unit, content) {
+    if (!unit) {
+        return false;
+    }
+    const productType = getProductTypeForUnit(content, unit);
+    const usesShareInventory = unit.inventoryMode === "shares" ||
+        productType?.inventoryMode === "shares" ||
+        Boolean(productType?.shareInventory);
+    if (!usesShareInventory) {
+        return false;
+    }
+    return (unit.id === content.entryInventory.corporateUnitId ||
+        isCorporateRentalUnit(unit));
+}
+export function getCorporateActionTotalShares({ availabilityByUnitId, content, unit, }) {
+    const availability = getInventoryAvailability(unit, availabilityByUnitId);
+    const productType = getProductTypeForUnit(content, unit);
+    return Math.max(availability?.share?.total ?? productType?.shareInventory?.totalShares ?? 1, 1);
+}
+export function clampCorporateActionCount(value) {
+    if (!Number.isFinite(value)) {
+        return CORPORATE_ACTION_MIN_COUNT;
+    }
+    return Math.min(CORPORATE_ACTION_MAX_COUNT, Math.max(CORPORATE_ACTION_MIN_COUNT, Math.round(value)));
+}
+export function parseCorporateActionCount(value) {
+    return clampCorporateActionCount(Number(value));
+}
+export function normalizeCorporateActionSchemeId(value) {
+    return (ENTRADA_ACTION_SCHEMES.find((scheme) => scheme.id === value)?.id ??
+        CORPORATE_ACTION_DEFAULT_SCHEME_ID);
+}
+export function buildCorporateActionPlan({ actionCount, availabilityByUnitId, content, schemeId, unit, }) {
+    return buildCorporatePlan({
+        inflationRate: content.financeRules.corporateInflationRate,
+        numActions: clampCorporateActionCount(actionCount),
+        requestedSchemeId: schemeId,
+        rentalRate: content.financeRules.accionesRentalRate,
+        totalShares: getCorporateActionTotalShares({
+            availabilityByUnitId,
+            content,
+            unit,
+        }),
+        unit,
+    });
+}
+export function getCorporateActionUnitDisplay({ availabilityByUnitId, content, unit, }) {
+    const totalShares = getCorporateActionTotalShares({
+        availabilityByUnitId,
+        content,
+        unit,
+    });
+    const pricePerActionMXN = getCorporatePricePerActionMXN(unit, totalShares);
+    const m2PerAction = getCorporateM2PerAction(unit, totalShares);
+    return {
+        m2PerAction,
+        monthlyRentPerActionMXN: (pricePerActionMXN * content.financeRules.accionesRentalRate) / 12,
+        pricePerActionMXN,
+        totalShares,
+    };
+}
+export function buildCorporateActionProductLabel(plan) {
+    const actionLabel = `${plan.numActions} ${plan.numActions === 1 ? "acción Serie B" : "acciones Serie B"}`;
+    return `Acciones corporativo · ${actionLabel}`;
+}
+export function buildCorporateActionCheckoutSelection(plan) {
+    return {
+        capitalMXN: plan.totalPaidMXN,
+        engancheMXN: plan.engancheMXN,
+        m2: plan.m2,
+        monthlyPaymentMXN: plan.monthlyPaymentMXN,
+        numActions: plan.numActions,
+        operationMonthlyReturnNetMXN: plan.operationMonthlyReturnNetMXN,
+        pricePerActionMXN: plan.pricePerActionMXN,
+        schemeId: plan.scheme.id,
+    };
+}

package/dist/corporate-rent.d.ts

@@ -0,0 +1,5 @@
+import type { InventoryUnit } from "./types.js";
+export declare const DEFAULT_CORPORATE_INFLATION_RATE = 0.04;
+export declare function isCorporateRentalUnit(unit: Pick<InventoryUnit, "category" | "name" | "productTypeName" | "unitNumber">): boolean;
+export declare function getEscalatedAnnualAmountMXN(baseAnnualAmountMXN: number, annualEscalationRate: number, yearNumber: number): number;
+export declare function getEscalatedAmountOverHorizonMXN(baseAnnualAmountMXN: number, annualEscalationRate: number, years: number): number;

package/dist/corporate-rent.js

@@ -0,0 +1,43 @@
+export const DEFAULT_CORPORATE_INFLATION_RATE = 0.04;
+const CORPORATE_RENT_CATEGORY_TOKENS = new Set(["corporativo", "acciones"]);
+function normalizeComparableLabel(value) {
+    return (value ?? "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, " ");
+}
+function matchesCorporateToken(value) {
+    const normalizedValue = normalizeComparableLabel(value);
+    if (!normalizedValue) {
+        return false;
+    }
+    if (CORPORATE_RENT_CATEGORY_TOKENS.has(normalizedValue)) {
+        return true;
+    }
+    return [...CORPORATE_RENT_CATEGORY_TOKENS].some((token) => normalizedValue.includes(token));
+}
+export function isCorporateRentalUnit(unit) {
+    return (matchesCorporateToken(unit.category) ||
+        matchesCorporateToken(unit.productTypeName) ||
+        matchesCorporateToken(unit.name) ||
+        matchesCorporateToken(unit.unitNumber));
+}
+export function getEscalatedAnnualAmountMXN(baseAnnualAmountMXN, annualEscalationRate, yearNumber) {
+    return (baseAnnualAmountMXN *
+        Math.pow(1 + Math.max(annualEscalationRate, 0), Math.max(yearNumber - 1, 0)));
+}
+export function getEscalatedAmountOverHorizonMXN(baseAnnualAmountMXN, annualEscalationRate, years) {
+    let totalMXN = 0;
+    let remainingYears = Math.max(years, 0);
+    let yearNumber = 1;
+    while (remainingYears > 0) {
+        const yearFraction = Math.min(remainingYears, 1);
+        totalMXN +=
+            getEscalatedAnnualAmountMXN(baseAnnualAmountMXN, annualEscalationRate, yearNumber) * yearFraction;
+        remainingYears -= yearFraction;
+        yearNumber += 1;
+    }
+    return totalMXN;
+}

package/dist/delivery-date.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeDeliveryDateInput(value: string | null | undefined): string | undefined;
+export declare function parseDeliveryDateParts(value: string): {
+    year: number;
+    month: number;
+} | null;
+export declare function isValidDeliveryDateString(value: string): boolean;

package/dist/delivery-date.js

@@ -0,0 +1,22 @@
+export function normalizeDeliveryDateInput(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function parseDeliveryDateParts(value) {
+    const match = /^(\d{4})-(\d{2})$/.exec(value.trim());
+    if (!match) {
+        return null;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    if (!Number.isFinite(year) ||
+        !Number.isFinite(month) ||
+        month < 1 ||
+        month > 12) {
+        return null;
+    }
+    return { year, month };
+}
+export function isValidDeliveryDateString(value) {
+    return parseDeliveryDateParts(value) !== null;
+}