@grupolapa/cotizador-sdk 0.1.0

package/dist/http.js

@@ -0,0 +1,133 @@
+export class CotizadorApiError extends Error {
+    constructor(response, body) {
+        super(body.message);
+        this.name = "CotizadorApiError";
+        this.code = body.code;
+        this.fieldErrors = body.fieldErrors;
+        this.response = response;
+        this.status = response.status;
+    }
+}
+function trimSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function normalizeBaseUrl(baseUrl) {
+    const trimmed = trimSlashes(baseUrl.trim());
+    if (!trimmed) {
+        throw new Error("Cotizador SDK baseUrl is required.");
+    }
+    return trimmed;
+}
+function getFetch(customFetch) {
+    const fetchImpl = customFetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("Cotizador SDK requires a fetch implementation in this runtime.");
+    }
+    return fetchImpl;
+}
+function appendLookup(params, lookup) {
+    if (lookup) {
+        params.set("lookup", lookup);
+    }
+}
+function appendInstanceSlug(params, instanceSlug) {
+    if (instanceSlug) {
+        params.set("instanceSlug", instanceSlug);
+    }
+}
+function buildQuery(args) {
+    const params = new URLSearchParams();
+    appendLookup(params, args.lookup);
+    appendInstanceSlug(params, args.instanceSlug);
+    if (args.unitIds && args.unitIds.length > 0) {
+        params.set("unitIds", args.unitIds.join(","));
+    }
+    if (args.includeShapes === false) {
+        params.set("includeShapes", "false");
+    }
+    const query = params.toString();
+    return query ? `?${query}` : "";
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(value);
+}
+function credentialHeaders(credential) {
+    if (!credential) {
+        return [];
+    }
+    return credential.kind === "apiKey"
+        ? [["x-cotizador-api-key", credential.value]]
+        : [["x-cotizador-session", credential.value]];
+}
+function buildHeaders(headers, credential) {
+    const requestHeaders = new Headers(headers);
+    requestHeaders.set("Accept", requestHeaders.get("Accept") ?? "application/json");
+    for (const [name, value] of credentialHeaders(credential)) {
+        requestHeaders.set(name, value);
+    }
+    return requestHeaders;
+}
+async function readJsonResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const isJson = contentType.includes("application/json");
+    const body = isJson ? await response.json() : null;
+    if (!response.ok) {
+        throw new CotizadorApiError(response, {
+            message: body && typeof body.message === "string"
+                ? body.message
+                : `Cotizador API request failed with status ${response.status}.`,
+            code: body && typeof body.code === "string" ? body.code : undefined,
+            fieldErrors: body &&
+                typeof body.fieldErrors === "object" &&
+                body.fieldErrors !== null
+                ? body.fieldErrors
+                : undefined,
+        });
+    }
+    return body;
+}
+export function createCotizadorApiRequester(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const fetchImpl = getFetch(options.fetch);
+    async function requestJson(path, init = {}) {
+        const { credential, headers, ...requestInit } = init;
+        const response = await fetchImpl(`${baseUrl}${path}`, {
+            ...requestInit,
+            headers: buildHeaders(headers, credential),
+        });
+        return await readJsonResponse(response);
+    }
+    return {
+        getAgentGuide: () => requestJson("/agent.json"),
+        getOpenApi: () => requestJson("/openapi.json"),
+        listInstances: (args) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/instances${buildQuery({
+            lookup: args.lookup,
+        })}`),
+        getSnapshot: (args) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/snapshot${buildQuery(args)}`),
+        getInventory: (args) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/inventory${buildQuery(args)}`),
+        getSitemap: (args) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/sitemap${buildQuery(args)}`),
+        getPaymentMethods: (args) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/payment-methods${buildQuery(args)}`),
+        createSession: (args, credential) => requestJson("/sessions", {
+            body: JSON.stringify({
+                lookup: args.lookup ?? "host",
+                origin: args.origin,
+                siteKey: args.siteKey,
+            }),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
+        createReservation: (args, credential) => requestJson(`/sites/${encodePathSegment(args.siteKey)}/reservations${buildQuery({
+            lookup: args.lookup,
+        })}`, {
+            body: JSON.stringify({
+                ...args.request,
+                instanceSlug: args.request.instanceSlug ?? args.instanceSlug,
+            }),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
+        getReservation: (args, credential) => requestJson(`/reservations/${encodePathSegment(args.externalReference)}`, { credential }),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { CotizadorApiError } from "./http.js";
+import type { CotizadorApiBaseOptions, CreatePublicReservationRequest, GetPublicReservationRequest } from "./types.js";
+export { CotizadorApiError };
+export type * from "./types.js";
+export declare function createCotizadorClient(options: CotizadorApiBaseOptions): {
+    createReservation: (args: CreatePublicReservationRequest) => Promise<import("./types.js").PublicReservationStatus>;
+    getAgentGuide: () => Promise<Record<string, unknown>>;
+    getInventory: (args: import("./types.js").CotizadorInventoryRequest) => Promise<import("./types.js").PublicInventoryResponse>;
+    getOpenApi: () => Promise<Record<string, unknown>>;
+    getPaymentMethods: (args: import("./types.js").CotizadorSiteRequest) => Promise<import("./types.js").PublicPaymentMethodsResponse>;
+    getReservation: (args: GetPublicReservationRequest) => Promise<import("./types.js").PublicReservationStatus>;
+    getSitemap: (args: import("./types.js").CotizadorSitemapRequest) => Promise<import("./types.js").PublicSitemapResponse>;
+    getSnapshot: (args: import("./types.js").CotizadorSiteRequest) => Promise<import("./types.js").PublicSnapshotResponse>;
+    listInstances: (args: Pick<import("./types.js").CotizadorSiteRequest, "lookup" | "siteKey">) => Promise<import("./types.js").PublicInstancesResponse>;
+};

package/dist/index.js

@@ -0,0 +1,22 @@
+import { CotizadorApiError, createCotizadorApiRequester } from "./http.js";
+export { CotizadorApiError };
+export function createCotizadorClient(options) {
+    const api = createCotizadorApiRequester(options);
+    function requireSessionToken(sessionToken) {
+        if (!sessionToken) {
+            throw new Error("A cotizador session token is required for browser write methods.");
+        }
+        return { kind: "session", value: sessionToken };
+    }
+    return {
+        createReservation: async (args) => api.createReservation(args, requireSessionToken(args.sessionToken)),
+        getAgentGuide: api.getAgentGuide,
+        getInventory: api.getInventory,
+        getOpenApi: api.getOpenApi,
+        getPaymentMethods: api.getPaymentMethods,
+        getReservation: async (args) => api.getReservation(args, requireSessionToken(args.sessionToken)),
+        getSitemap: api.getSitemap,
+        getSnapshot: api.getSnapshot,
+        listInstances: api.listInstances,
+    };
+}

package/dist/installment-allocation.d.ts

@@ -0,0 +1,30 @@
+export declare const INSTALLMENT_DOWN_PAYMENT_RANGE: {
+    readonly min: 20;
+    readonly max: 100;
+    readonly step: 5;
+};
+export declare const INSTALLMENT_MONTHLY_BASE_RANGE: {
+    readonly min: 20;
+    readonly max: 40;
+    readonly step: 5;
+};
+export declare const INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT = 40;
+export declare const INSTALLMENT_DEFAULT_MONTHLY_PCT = 20;
+export declare const INSTALLMENT_DISCOUNT_THRESHOLD_PCT = 30;
+export declare const INSTALLMENT_DISCOUNT_INCREMENT_PCT = 10;
+export declare const INSTALLMENT_DISCOUNT_STEP_PCT = 1.25;
+export declare function getInstallmentDiscountPct(downPaymentPct: number): number;
+export declare function clampInstallmentDownPaymentPct(value: number): number;
+export declare function getInstallmentMonthlyRange(downPaymentPct: number): {
+    min: number;
+    max: number;
+    step: 5;
+};
+export declare function clampInstallmentMonthlyPct(monthlyPct: number, downPaymentPct: number): number;
+export interface InstallmentAllocation {
+    downPaymentPct: number;
+    monthlyPct: number;
+    deferredPct: number;
+    deliveryPct: number;
+}
+export declare function getInstallmentAllocation(downPaymentPct: number, monthlyPct: number): InstallmentAllocation;

package/dist/installment-allocation.js

@@ -0,0 +1,69 @@
+export const INSTALLMENT_DOWN_PAYMENT_RANGE = {
+    min: 20,
+    max: 100,
+    step: 5,
+};
+export const INSTALLMENT_MONTHLY_BASE_RANGE = {
+    min: 20,
+    max: 40,
+    step: 5,
+};
+export const INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT = 40;
+export const INSTALLMENT_DEFAULT_MONTHLY_PCT = 20;
+export const INSTALLMENT_DISCOUNT_THRESHOLD_PCT = 30;
+export const INSTALLMENT_DISCOUNT_INCREMENT_PCT = 10;
+export const INSTALLMENT_DISCOUNT_STEP_PCT = 1.25;
+export function getInstallmentDiscountPct(downPaymentPct) {
+    if (downPaymentPct < INSTALLMENT_DISCOUNT_THRESHOLD_PCT) {
+        return 0;
+    }
+    const steps = Math.floor((downPaymentPct - INSTALLMENT_DISCOUNT_THRESHOLD_PCT) /
+        INSTALLMENT_DISCOUNT_INCREMENT_PCT);
+    return (steps + 1) * INSTALLMENT_DISCOUNT_STEP_PCT;
+}
+const INSTALLMENT_BASE_DOWN_PAYMENT_PCT = INSTALLMENT_DOWN_PAYMENT_RANGE.min;
+const INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT = INSTALLMENT_MONTHLY_BASE_RANGE.max;
+function clampToRangeBounds(value, min, max, step) {
+    const clamped = Math.min(max, Math.max(min, value));
+    return min + Math.round((clamped - min) / step) * step;
+}
+export function clampInstallmentDownPaymentPct(value) {
+    return clampToRangeBounds(value, INSTALLMENT_DOWN_PAYMENT_RANGE.min, INSTALLMENT_DOWN_PAYMENT_RANGE.max, INSTALLMENT_DOWN_PAYMENT_RANGE.step);
+}
+export function getInstallmentMonthlyRange(downPaymentPct) {
+    const downPct = clampInstallmentDownPaymentPct(downPaymentPct);
+    const totalRemaining = 100 - downPct;
+    const max = Math.min(INSTALLMENT_MONTHLY_BASE_RANGE.max, totalRemaining);
+    const min = Math.min(INSTALLMENT_MONTHLY_BASE_RANGE.min, max);
+    return { min, max, step: INSTALLMENT_MONTHLY_BASE_RANGE.step };
+}
+export function clampInstallmentMonthlyPct(monthlyPct, downPaymentPct) {
+    const range = getInstallmentMonthlyRange(downPaymentPct);
+    return clampToRangeBounds(monthlyPct, range.min, range.max, range.step);
+}
+export function getInstallmentAllocation(downPaymentPct, monthlyPct) {
+    const downPct = clampInstallmentDownPaymentPct(downPaymentPct);
+    const baseMonthly = clampInstallmentMonthlyPct(monthlyPct, downPct);
+    const baseDeferred = INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT - baseMonthly;
+    const baseDelivery = 100 -
+        INSTALLMENT_BASE_DOWN_PAYMENT_PCT -
+        INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT;
+    let extra = Math.max(0, downPct - INSTALLMENT_BASE_DOWN_PAYMENT_PCT);
+    let delivery = baseDelivery;
+    let deferred = baseDeferred;
+    let monthly = baseMonthly;
+    const fromDeferred = Math.min(deferred, extra);
+    deferred -= fromDeferred;
+    extra -= fromDeferred;
+    const fromDelivery = Math.min(delivery, extra);
+    delivery -= fromDelivery;
+    extra -= fromDelivery;
+    const fromMonthly = Math.min(monthly, extra);
+    monthly -= fromMonthly;
+    return {
+        downPaymentPct: downPct,
+        monthlyPct: monthly,
+        deferredPct: deferred,
+        deliveryPct: delivery,
+    };
+}

package/dist/inventory-availability.d.ts

@@ -0,0 +1,10 @@
+import type { AppContent, InventoryAvailability, InventoryAvailabilityByUnitId, InventoryStatus, InventoryStatusLabels, InventoryUnit } from "./types.js";
+type PaidShareSalesByProductTypeId = Record<string, number>;
+export declare function buildInventoryAvailabilityByUnitId(content: AppContent, paidShareSalesByProductTypeId?: PaidShareSalesByProductTypeId): InventoryAvailabilityByUnitId;
+export declare function getInventoryAvailability(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): InventoryAvailability | null;
+export declare function getResolvedInventoryStatus(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): InventoryStatus | null;
+export declare function canCheckoutInventoryUnit(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): boolean;
+export declare function canCheckoutInventoryQuantity(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId, quantity: number): boolean;
+export declare function getResolvedInventoryStatusLabel(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId, statusLabels: InventoryStatusLabels): string;
+export declare function getResolvedShareSummary(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): import("./types.js").InventoryShareAvailability | null;
+export {};

package/dist/inventory-availability.js

@@ -0,0 +1,105 @@
+function buildBaseAvailability(unit, inventoryMode) {
+    return {
+        unitId: unit.id,
+        productTypeId: unit.productTypeId,
+        inventoryMode,
+        status: unit.status,
+        canCheckout: unit.status === "available",
+    };
+}
+function blocksCheckout(status) {
+    return status !== "available";
+}
+function getProductTypeById(content) {
+    return new Map(content.productTypes.map((productType) => [productType.id, productType]));
+}
+function getShareModeAvailability(unit, productType, soldPaid) {
+    const total = productType.shareInventory?.totalShares ?? 1;
+    const soldBaseline = productType.shareInventory?.soldSharesBaseline ?? 0;
+    const soldTotal = soldBaseline + soldPaid;
+    const remaining = Math.max(total - soldTotal, 0);
+    if (blocksCheckout(unit.status)) {
+        return {
+            ...buildBaseAvailability(unit, "shares"),
+            canCheckout: false,
+            share: {
+                total,
+                soldBaseline,
+                soldPaid,
+                soldTotal,
+                remaining,
+            },
+        };
+    }
+    return {
+        ...buildBaseAvailability(unit, "shares"),
+        status: remaining > 0 ? "available" : "sold",
+        canCheckout: remaining > 0,
+        isSoldOutByShares: remaining <= 0,
+        share: {
+            total,
+            soldBaseline,
+            soldPaid,
+            soldTotal,
+            remaining,
+        },
+    };
+}
+export function buildInventoryAvailabilityByUnitId(content, paidShareSalesByProductTypeId = {}) {
+    const productTypeById = getProductTypeById(content);
+    return Object.fromEntries(content.inventory.map((unit) => {
+        const productType = productTypeById.get(unit.productTypeId);
+        const availability = productType?.inventoryMode === "shares"
+            ? getShareModeAvailability(unit, productType, paidShareSalesByProductTypeId[productType.id] ?? 0)
+            : buildBaseAvailability(unit, productType?.inventoryMode ?? unit.inventoryMode ?? "units");
+        return [unit.id, availability];
+    }));
+}
+export function getInventoryAvailability(unit, availabilityByUnitId) {
+    if (!unit) {
+        return null;
+    }
+    return availabilityByUnitId[unit.id] ?? null;
+}
+export function getResolvedInventoryStatus(unit, availabilityByUnitId) {
+    if (!unit) {
+        return null;
+    }
+    return (getInventoryAvailability(unit, availabilityByUnitId)?.status ?? unit.status);
+}
+export function canCheckoutInventoryUnit(unit, availabilityByUnitId) {
+    return canCheckoutInventoryQuantity(unit, availabilityByUnitId, 1);
+}
+export function canCheckoutInventoryQuantity(unit, availabilityByUnitId, quantity) {
+    if (!unit) {
+        return false;
+    }
+    const availability = getInventoryAvailability(unit, availabilityByUnitId);
+    if (!availability?.canCheckout) {
+        return false;
+    }
+    if (availability.inventoryMode !== "shares") {
+        return quantity <= 1;
+    }
+    if (!Number.isFinite(quantity) || quantity <= 0) {
+        return false;
+    }
+    return (availability.share?.remaining ?? 0) >= quantity;
+}
+export function getResolvedInventoryStatusLabel(unit, availabilityByUnitId, statusLabels) {
+    if (!unit) {
+        return "";
+    }
+    const availability = getInventoryAvailability(unit, availabilityByUnitId);
+    if (availability?.isSoldOutByShares) {
+        return "Agotado";
+    }
+    const resolvedStatus = availability?.status ?? unit.status;
+    if (resolvedStatus === "unavailable") {
+        return statusLabels.unavailable ?? "No disponible";
+    }
+    return statusLabels[resolvedStatus] ?? resolvedStatus;
+}
+export function getResolvedShareSummary(unit, availabilityByUnitId) {
+    return getInventoryAvailability(unit, availabilityByUnitId)?.share ?? null;
+}

package/dist/live-inventory-availability.d.ts

@@ -0,0 +1,16 @@
+import type { AppContent, InventoryAvailabilityByUnitId, InventoryShareAvailability, InventoryStatus } from "./types.js";
+export interface LiveInventoryAvailability {
+    status: InventoryStatus;
+    canCheckout: boolean;
+    isSoldOutByShares?: boolean;
+    share?: InventoryShareAvailability;
+}
+export type LiveInventoryAvailabilityByUnitId = Record<string, LiveInventoryAvailability>;
+export declare function toInventoryStatus(value: string | undefined): InventoryStatus;
+export declare function buildLiveInventoryAvailabilityFromLot(lot: {
+    disponibilidad?: string;
+    shares?: number;
+    sharesSold?: number;
+}): LiveInventoryAvailability;
+export declare function getLiveInventoryUnitIds(content: AppContent): string[];
+export declare function mergeLiveInventoryAvailabilityByUnitId(base: InventoryAvailabilityByUnitId, live: LiveInventoryAvailabilityByUnitId | null | undefined): InventoryAvailabilityByUnitId;

package/dist/live-inventory-availability.js

@@ -0,0 +1,88 @@
+export function toInventoryStatus(value) {
+    if (value === "Apartado")
+        return "reserved";
+    if (value === "Vendido")
+        return "sold";
+    if (value === "No Disponible")
+        return "unavailable";
+    return "available";
+}
+export function buildLiveInventoryAvailabilityFromLot(lot) {
+    const status = toInventoryStatus(lot.disponibilidad);
+    if (!lot.shares || lot.shares <= 0) {
+        return {
+            status,
+            canCheckout: status === "available",
+        };
+    }
+    const total = lot.shares ?? 1;
+    const soldBaseline = Math.min(lot.sharesSold ?? 0, lot.shares ?? lot.sharesSold ?? 0);
+    const soldTotal = soldBaseline;
+    const remaining = Math.max(total - soldTotal, 0);
+    const share = {
+        total,
+        soldBaseline,
+        soldPaid: 0,
+        soldTotal,
+        remaining,
+    };
+    if (status !== "available") {
+        return {
+            status,
+            canCheckout: false,
+            isSoldOutByShares: remaining <= 0,
+            share,
+        };
+    }
+    return {
+        status: remaining > 0 ? "available" : "sold",
+        canCheckout: remaining > 0,
+        isSoldOutByShares: remaining <= 0,
+        share,
+    };
+}
+export function getLiveInventoryUnitIds(content) {
+    return Array.from(new Set(content.inventory.map((unit) => unit.id.trim()).filter(Boolean))).toSorted();
+}
+function sharesEqual(left, right) {
+    if (!left && !right)
+        return true;
+    if (!left || !right)
+        return false;
+    return (left.total === right.total &&
+        left.soldBaseline === right.soldBaseline &&
+        left.soldPaid === right.soldPaid &&
+        left.soldTotal === right.soldTotal &&
+        left.remaining === right.remaining);
+}
+export function mergeLiveInventoryAvailabilityByUnitId(base, live) {
+    if (!live) {
+        return base;
+    }
+    let changed = false;
+    const next = { ...base };
+    for (const [unitId, liveAvailability] of Object.entries(live)) {
+        const current = base[unitId];
+        if (!current)
+            continue;
+        const merged = {
+            ...current,
+            status: liveAvailability.status,
+            canCheckout: liveAvailability.canCheckout,
+            ...(liveAvailability.isSoldOutByShares !== undefined
+                ? { isSoldOutByShares: liveAvailability.isSoldOutByShares }
+                : {}),
+            ...(liveAvailability.share !== undefined
+                ? { share: liveAvailability.share }
+                : {}),
+        };
+        if (current.status !== merged.status ||
+            current.canCheckout !== merged.canCheckout ||
+            current.isSoldOutByShares !== merged.isSoldOutByShares ||
+            !sharesEqual(current.share, merged.share)) {
+            next[unitId] = merged;
+            changed = true;
+        }
+    }
+    return changed ? next : base;
+}

package/dist/payment-schemes.d.ts

@@ -0,0 +1,22 @@
+import type { CashbackPaymentScheme, FinanceRules, InstallmentPaymentScheme, InventoryUnit, PaymentSchemeDefinition, RangeRule } from "./types.js";
+export declare const MAX_CASHBACK_MONTHS = 30;
+export declare function getUnitListPriceMXN(unit: InventoryUnit): number;
+export declare function getUnitEstimatedRentalAnnualMXN(unit: InventoryUnit, rentalRate: number, includeIva: boolean): number;
+export declare function getUnitEstimatedRentalMonthlyMXN(unit: InventoryUnit, rentalRate: number, includeIva: boolean): number;
+export declare function getFinanceRulesRentalRateForUnit(unit: InventoryUnit, financeRules: FinanceRules): number;
+export declare function getUnitDeliveryDateParts(unit: InventoryUnit): {
+    year: number;
+    month: number;
+} | null;
+export declare function getUnitDeliveryLabel(unit: InventoryUnit): string;
+export declare function getUnitDeliveryMonths(unit: InventoryUnit, referenceDate?: Date): number;
+export declare function isCashbackScheme(scheme: PaymentSchemeDefinition): scheme is CashbackPaymentScheme;
+export declare function isInstallmentScheme(scheme: PaymentSchemeDefinition): scheme is InstallmentPaymentScheme;
+export declare function getPaymentSchemeById(paymentSchemes: PaymentSchemeDefinition[], schemeId: string): PaymentSchemeDefinition | null;
+export declare function getActivePaymentSchemes(paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition[];
+export declare function getAllowedPaymentSchemes(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition[];
+export declare function getDefaultSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition;
+export declare function getResolvedSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[], requestedSchemeId: string | null | undefined): PaymentSchemeDefinition;
+export declare function clampToRange(value: number, range: RangeRule): number;
+export declare function getSchemeDownPaymentRange(scheme: PaymentSchemeDefinition | null): RangeRule | null;
+export declare function getDefaultDownPaymentPctForScheme(scheme: PaymentSchemeDefinition | null, financeRules: FinanceRules): number;

package/dist/payment-schemes.js

@@ -0,0 +1,99 @@
+import { parseDeliveryDateParts } from "./delivery-date.js";
+import { isCorporateRentalUnit } from "./corporate-rent.js";
+import { applyIvaModeMXN } from "./tax.js";
+function roundCurrency(value) {
+    return Math.round(value * 100) / 100;
+}
+const MONTH_LABELS = [
+    "Enero",
+    "Febrero",
+    "Marzo",
+    "Abril",
+    "Mayo",
+    "Junio",
+    "Julio",
+    "Agosto",
+    "Septiembre",
+    "Octubre",
+    "Noviembre",
+    "Diciembre",
+];
+export const MAX_CASHBACK_MONTHS = 30;
+export function getUnitListPriceMXN(unit) {
+    return roundCurrency(unit.areaM2 * unit.pricePerM2MXN);
+}
+export function getUnitEstimatedRentalAnnualMXN(unit, rentalRate, includeIva) {
+    return applyIvaModeMXN(getUnitListPriceMXN(unit), includeIva) * rentalRate;
+}
+export function getUnitEstimatedRentalMonthlyMXN(unit, rentalRate, includeIva) {
+    return getUnitEstimatedRentalAnnualMXN(unit, rentalRate, includeIva) / 12;
+}
+export function getFinanceRulesRentalRateForUnit(unit, financeRules) {
+    return isCorporateRentalUnit(unit)
+        ? financeRules.accionesRentalRate
+        : financeRules.rentalRate;
+}
+export function getUnitDeliveryDateParts(unit) {
+    return parseDeliveryDateParts(unit.deliveryDate);
+}
+export function getUnitDeliveryLabel(unit) {
+    const parts = getUnitDeliveryDateParts(unit);
+    if (!parts) {
+        return "Por definir";
+    }
+    return `${MONTH_LABELS[parts.month - 1]} ${parts.year}`;
+}
+export function getUnitDeliveryMonths(unit, referenceDate = new Date()) {
+    const parts = getUnitDeliveryDateParts(unit);
+    if (!parts) {
+        return 1;
+    }
+    const currentYear = referenceDate.getFullYear();
+    const currentMonth = referenceDate.getMonth() + 1;
+    const diff = (parts.year - currentYear) * 12 + (parts.month - currentMonth);
+    return Math.max(diff, 1);
+}
+export function isCashbackScheme(scheme) {
+    return scheme.type === "cashback";
+}
+export function isInstallmentScheme(scheme) {
+    return scheme.type === "installment";
+}
+export function getPaymentSchemeById(paymentSchemes, schemeId) {
+    return paymentSchemes.find((scheme) => scheme.id === schemeId) ?? null;
+}
+export function getActivePaymentSchemes(paymentSchemes) {
+    return paymentSchemes.filter((scheme) => scheme.active);
+}
+export function getAllowedPaymentSchemes(unit, paymentSchemes) {
+    return unit.allowedSchemeIds
+        .map((schemeId) => getPaymentSchemeById(paymentSchemes, schemeId))
+        .filter((scheme) => Boolean(scheme?.active));
+}
+export function getDefaultSchemeForUnit(unit, paymentSchemes) {
+    const allowedSchemes = getAllowedPaymentSchemes(unit, paymentSchemes);
+    return (allowedSchemes.find((scheme) => scheme.id === unit.defaultSchemeId) ??
+        allowedSchemes[0] ??
+        getActivePaymentSchemes(paymentSchemes)[0] ??
+        null);
+}
+export function getResolvedSchemeForUnit(unit, paymentSchemes, requestedSchemeId) {
+    const allowedSchemes = getAllowedPaymentSchemes(unit, paymentSchemes);
+    return (allowedSchemes.find((scheme) => scheme.id === requestedSchemeId) ??
+        getDefaultSchemeForUnit(unit, paymentSchemes));
+}
+export function clampToRange(value, range) {
+    const clamped = Math.min(range.max, Math.max(range.min, value));
+    const steps = Math.round((clamped - range.min) / range.step);
+    return range.min + steps * range.step;
+}
+export function getSchemeDownPaymentRange(scheme) {
+    return scheme && isCashbackScheme(scheme) ? scheme.downPaymentRange : null;
+}
+export function getDefaultDownPaymentPctForScheme(scheme, financeRules) {
+    const range = getSchemeDownPaymentRange(scheme);
+    if (!range) {
+        return financeRules.defaults.downPaymentPct;
+    }
+    return clampToRange(financeRules.defaults.downPaymentPct, range);
+}

package/dist/post-delivery-value.d.ts

@@ -0,0 +1,3 @@
+import type { PostDeliveryValueRow, ProjectionPoint } from "./types.js";
+export declare function buildAnnualPostDeliveryValueRows(projectionPoints: ProjectionPoint[]): PostDeliveryValueRow[];
+export declare function buildQuarterlyPostDeliveryValueRows(projectionPoints: ProjectionPoint[]): PostDeliveryValueRow[];