@grupolapa/cotizador-sdk 0.1.0

package/README.md

@@ -0,0 +1,125 @@
+# Cotizador SDK
+
+Framework-agnostic TypeScript helpers for building a cotizador against the
+deployed Grupo LAPA public API.
+
+## Installation
+
+```bash
+npm install @grupolapa/cotizador-sdk
+```
+
+```bash
+pnpm add @grupolapa/cotizador-sdk
+```
+
+The SDK has separate browser-safe and trusted-server entry points. Keep API keys
+on a server and pass only short-lived session tokens to browser code.
+
+## Browser Reads and Quotes
+
+```ts
+import { createCotizadorClient } from "@grupolapa/cotizador-sdk";
+import {
+  calculateQuote,
+  getResolvedSchemeForUnit,
+} from "@grupolapa/cotizador-sdk/quote";
+import {
+  getSelectableUnitHotspots,
+  resolveInitialSitemapMap,
+} from "@grupolapa/cotizador-sdk/sitemap";
+
+const client = createCotizadorClient({
+  baseUrl: "https://grupolapa.com/api/public/v1/cotizador",
+});
+
+const siteKey = "viamare.mx";
+const [{ snapshot }, inventory, sitemap, paymentMethods] = await Promise.all([
+  client.getSnapshot({ siteKey }),
+  client.getInventory({ siteKey }),
+  client.getSitemap({ siteKey }),
+  client.getPaymentMethods({ siteKey }),
+]);
+
+const map = resolveInitialSitemapMap(sitemap);
+const hotspots = map ? getSelectableUnitHotspots(map) : [];
+const unit = inventory.inventory.find(
+  (item) => item.id === hotspots[0]?.unitId,
+);
+const scheme = unit
+  ? getResolvedSchemeForUnit(unit, snapshot.content.paymentSchemes, null)
+  : null;
+
+const quote =
+  unit && scheme
+    ? calculateQuote(
+        unit,
+        {
+          unitId: unit.id,
+          scheme: scheme.id,
+          plusvaliaAnnualPct:
+            snapshot.content.financeRules.defaults.plusvaliaAnnualPct,
+          postDeliveryYears:
+            snapshot.content.financeRules.defaults.postDeliveryYears,
+          downPaymentPct: snapshot.content.financeRules.defaults.downPaymentPct,
+          includeIva: false,
+        },
+        scheme,
+        snapshot.content.financeRules,
+      )
+    : null;
+```
+
+## Server Session Flow
+
+```ts
+import { createCotizadorServerClient } from "@grupolapa/cotizador-sdk/server";
+
+const serverClient = createCotizadorServerClient({
+  baseUrl: "https://grupolapa.com/api/public/v1/cotizador",
+  apiKey: process.env.COTIZADOR_API_KEY!,
+});
+
+export async function createBrowserSession(origin: string) {
+  return await serverClient.createBrowserSession({
+    siteKey: "viamare.mx",
+    lookup: "host",
+    origin,
+  });
+}
+```
+
+Do not expose `lapa_ctz_<prefix>_<secret>` API keys to browser code. Browser
+reservation writes should use `createCotizadorClient` with the short-lived
+session token returned by the server.
+
+## Sitemap Rendering
+
+The API returns image and overlay asset URLs plus SVG-native shape metadata.
+The SDK does not mutate the DOM. Use the sitemap helpers to choose maps and
+resolve unit hotspots, then render the overlay with the frontend framework of
+your choice.
+
+```ts
+import {
+  getShapeForUnit,
+  getSitemapMapAssetPlan,
+  resolveInitialSitemapMap,
+} from "@grupolapa/cotizador-sdk/sitemap";
+
+const map = resolveInitialSitemapMap(sitemap);
+if (map) {
+  const assets = getSitemapMapAssetPlan(map);
+  const shape = getShapeForUnit(map, selectedUnitId);
+}
+```
+
+## Exports
+
+- `@grupolapa/cotizador-sdk`: browser-safe client, public types, and
+  `CotizadorApiError`.
+- `@grupolapa/cotizador-sdk/server`: trusted server API-key client.
+- `@grupolapa/cotizador-sdk/quote`: quote, selection, payment, inventory,
+  formatting, Entrada/action, and product helpers.
+- `@grupolapa/cotizador-sdk/sitemap`: sitemap asset, hotspot, and shape helpers.
+- `@grupolapa/cotizador-sdk/types`: domain and public REST TypeScript types.

package/dist/bundle-payment-schedule.calc.d.ts

@@ -0,0 +1,2 @@
+import type { QuoteResult } from "./types.js";
+export declare function aggregateQuoteResults(quotes: QuoteResult[]): QuoteResult;

package/dist/bundle-payment-schedule.calc.js

@@ -0,0 +1,160 @@
+function sumBy(items, getValue) {
+    return items.reduce((total, item) => total + getValue(item), 0);
+}
+function roundPct(value) {
+    return Math.round(value * 100) / 100;
+}
+function getTimelineRowAtOrAfterDelivery(quote, month) {
+    return (quote.timelineRows[month] ??
+        quote.timelineRows.at(-1) ??
+        quote.timelineRows[0]);
+}
+function joinLabels(labels) {
+    const uniqueLabels = [...new Set(labels.filter(Boolean))];
+    if (uniqueLabels.length === 0) {
+        return "—";
+    }
+    if (uniqueLabels.length === 1) {
+        return uniqueLabels[0];
+    }
+    return uniqueLabels.join(" + ");
+}
+function aggregateTimelineRows(quotes) {
+    const maxDeliveryMonths = Math.max(...quotes.map((quote) => quote.deliveryMonths));
+    return Array.from({ length: maxDeliveryMonths + 1 }, (_, month) => {
+        const exactRows = quotes
+            .map((quote) => quote.timelineRows[month] ?? null)
+            .filter((row) => Boolean(row));
+        const accumulatedRows = quotes.map((quote) => getTimelineRowAtOrAfterDelivery(quote, month));
+        const paymentLabels = exactRows
+            .filter((row) => row.paymentMXN > 0.005)
+            .map((row) => row.paymentLabel);
+        const milestoneLabels = exactRows
+            .filter((row) => row.isMilestone)
+            .map((row) => row.milestoneLabel);
+        return {
+            month,
+            paymentMXN: sumBy(exactRows, (row) => row.paymentMXN),
+            paymentLabel: joinLabels(paymentLabels),
+            cashbackMXN: sumBy(exactRows, (row) => row.cashbackMXN),
+            plusvaliaDeltaMXN: sumBy(exactRows, (row) => row.plusvaliaDeltaMXN),
+            accumulatedCashbackMXN: sumBy(accumulatedRows, (row) => row.accumulatedCashbackMXN),
+            accumulatedPlusvaliaMXN: sumBy(accumulatedRows, (row) => row.accumulatedPlusvaliaMXN),
+            assetValueMXN: sumBy(accumulatedRows, (row) => row.assetValueMXN),
+            isMilestone: milestoneLabels.length > 0,
+            milestoneLabel: joinLabels(milestoneLabels),
+        };
+    });
+}
+function aggregateProjectionPoints(quotes) {
+    const maxYearOffset = Math.max(...quotes.map((quote) => quote.projectionPoints.at(-1)?.yearOffset ?? 0));
+    return Array.from({ length: maxYearOffset + 1 }, (_, yearOffset) => {
+        const points = quotes.map((quote) => quote.projectionPoints.find((point) => point.yearOffset === yearOffset) ??
+            quote.projectionPoints.at(-1) ??
+            quote.projectionPoints[0]);
+        return {
+            yearOffset,
+            label: yearOffset === 0 ? "Entrega" : `Año +${yearOffset}`,
+            assetValueMXN: sumBy(points, (point) => point.assetValueMXN),
+            rentalAccumulatedMXN: sumBy(points, (point) => point.rentalAccumulatedMXN),
+            valueWithRentMXN: sumBy(points, (point) => point.valueWithRentMXN),
+        };
+    });
+}
+function aggregateBreakdownItems(items) {
+    const itemMap = new Map();
+    for (const item of items) {
+        const existing = itemMap.get(item.label);
+        if (existing) {
+            existing.valueMXN += item.valueMXN;
+        }
+        else {
+            itemMap.set(item.label, { ...item });
+        }
+    }
+    return [...itemMap.values()];
+}
+function countTimelineRows(rows, matchesLabel) {
+    return rows.filter((row) => row.paymentMXN > 0.005 && matchesLabel(row.paymentLabel)).length;
+}
+function sumTimelinePayments(rows, matchesLabel) {
+    return sumBy(rows.filter((row) => row.paymentMXN > 0.005 && matchesLabel(row.paymentLabel)), (row) => row.paymentMXN);
+}
+function labelIncludes(label, search) {
+    return label.toLocaleLowerCase("es-MX").includes(search);
+}
+export function aggregateQuoteResults(quotes) {
+    if (quotes.length === 0) {
+        throw new Error("At least one quote is required to aggregate a schedule.");
+    }
+    const [representativeQuote] = quotes;
+    const timelineRows = aggregateTimelineRows(quotes);
+    const projectionPoints = aggregateProjectionPoints(quotes);
+    const listPriceMXN = sumBy(quotes, (quote) => quote.listPriceMXN);
+    const downPaymentAmountMXN = sumBy(quotes, (quote) => quote.downPaymentAmountMXN);
+    const balanceAmountMXN = sumBy(quotes, (quote) => quote.balanceAmountMXN);
+    const cashbackTotalMXN = sumBy(quotes, (quote) => quote.cashbackTotalMXN);
+    const installmentDiscountMXN = sumBy(quotes, (quote) => quote.installmentDiscountMXN);
+    const netCostMXN = sumBy(quotes, (quote) => quote.netCostMXN);
+    const monthlyPaymentCount = countTimelineRows(timelineRows, (label) => labelIncludes(label, "mensualidad"));
+    const monthlyPaymentTotalMXN = sumTimelinePayments(timelineRows, (label) => labelIncludes(label, "mensualidad"));
+    const deferredPaymentsCount = countTimelineRows(timelineRows, (label) => labelIncludes(label, "anualidad"));
+    const deferredPaymentsTotalMXN = sumTimelinePayments(timelineRows, (label) => labelIncludes(label, "anualidad"));
+    const deliveryPaymentAmountMXN = sumTimelinePayments(timelineRows, (label) => labelIncludes(label, "contra entrega"));
+    const finalTimelineRow = timelineRows.at(-1);
+    const finalProjectionPoint = projectionPoints.at(-1);
+    return {
+        ...representativeQuote,
+        listPriceMXN,
+        deliveryMonths: finalTimelineRow.month,
+        cashbackMonths: Math.max(...quotes.map((quote) => quote.cashbackMonths)),
+        isCashbackCapped: quotes.some((quote) => quote.isCashbackCapped),
+        downPaymentPct: listPriceMXN > 0
+            ? roundPct((downPaymentAmountMXN / listPriceMXN) * 100)
+            : 0,
+        downPaymentAmountMXN,
+        balanceAmountMXN,
+        cashbackMonthlyMXN: sumBy(quotes, (quote) => quote.cashbackMonthlyMXN),
+        cashbackTotalMXN,
+        installmentDiscountPct: listPriceMXN > 0
+            ? roundPct((installmentDiscountMXN / listPriceMXN) * 100)
+            : 0,
+        installmentDiscountMXN,
+        monthlyPaymentPct: listPriceMXN > 0
+            ? roundPct((monthlyPaymentTotalMXN / listPriceMXN) * 100)
+            : 0,
+        monthlyPaymentCount,
+        monthlyPaymentAmountMXN: monthlyPaymentCount > 0
+            ? monthlyPaymentTotalMXN / monthlyPaymentCount
+            : 0,
+        deferredPaymentPct: listPriceMXN > 0
+            ? roundPct((deferredPaymentsTotalMXN / listPriceMXN) * 100)
+            : 0,
+        deferredPaymentsTotalMXN,
+        deferredPaymentsCount,
+        deferredPaymentMonths: timelineRows
+            .filter((row) => row.paymentMXN > 0.005 &&
+            labelIncludes(row.paymentLabel, "anualidad"))
+            .map((row) => row.month),
+        deferredPaymentAmountMXN: deferredPaymentsCount > 0
+            ? deferredPaymentsTotalMXN / deferredPaymentsCount
+            : 0,
+        deliveryPaymentPct: listPriceMXN > 0
+            ? roundPct((deliveryPaymentAmountMXN / listPriceMXN) * 100)
+            : 0,
+        deliveryPaymentAmountMXN,
+        netCostMXN,
+        plusvaliaAtDeliveryMXN: finalTimelineRow.accumulatedPlusvaliaMXN,
+        plusvaliaPostDeliveryMXN: sumBy(quotes, (quote) => quote.plusvaliaPostDeliveryMXN),
+        totalGainMXN: sumBy(quotes, (quote) => quote.totalGainMXN),
+        finalAssetValueMXN: finalTimelineRow.assetValueMXN,
+        projectedAssetValueMXN: finalProjectionPoint.assetValueMXN,
+        rentalMonthlyMXN: sumBy(quotes, (quote) => quote.rentalMonthlyMXN),
+        rentalAccumulatedMXN: finalProjectionPoint.rentalAccumulatedMXN,
+        projectionPoints,
+        timelineRows,
+        visibleTimelineRows: timelineRows.filter((row) => row.paymentMXN > 0.005 || row.isMilestone),
+        costBreakdown: aggregateBreakdownItems(quotes.flatMap((quote) => quote.costBreakdown)),
+        gainBreakdown: aggregateBreakdownItems(quotes.flatMap((quote) => quote.gainBreakdown)),
+    };
+}

package/dist/calculate-quote.d.ts

@@ -0,0 +1,2 @@
+import type { FinanceRules, InventoryUnit, PaymentSchemeDefinition, QuoteInput, QuoteResult } from "./types.js";
+export declare function calculateQuote(unit: InventoryUnit, input: QuoteInput, scheme: PaymentSchemeDefinition, rules: FinanceRules): QuoteResult;

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,
+    };
+}