@grupolapa/desarrollos-sdk 0.1.0

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[];

package/dist/post-delivery-value.js

@@ -0,0 +1,61 @@
+function createRow(periodIndex, label, previousPoint, currentPoint) {
+    const plusvaliaDeltaMXN = currentPoint.assetValueMXN - previousPoint.assetValueMXN;
+    const rentalDeltaMXN = currentPoint.rentalAccumulatedMXN - previousPoint.rentalAccumulatedMXN;
+    return {
+        periodIndex,
+        label,
+        plusvaliaDeltaMXN,
+        rentalDeltaMXN,
+        valueAddedMXN: plusvaliaDeltaMXN + rentalDeltaMXN,
+        assetValueMXN: currentPoint.assetValueMXN,
+        rentalAccumulatedMXN: currentPoint.rentalAccumulatedMXN,
+        ownerValueMXN: currentPoint.valueWithRentMXN,
+    };
+}
+function getInterpolatedPoint(previousYearPoint, nextYearPoint, progress) {
+    const assetGrowthRatio = previousYearPoint.assetValueMXN > 0
+        ? nextYearPoint.assetValueMXN / previousYearPoint.assetValueMXN
+        : 1;
+    const assetValueMXN = previousYearPoint.assetValueMXN * Math.pow(assetGrowthRatio, progress);
+    const rentalAccumulatedMXN = previousYearPoint.rentalAccumulatedMXN +
+        (nextYearPoint.rentalAccumulatedMXN -
+            previousYearPoint.rentalAccumulatedMXN) *
+            progress;
+    return {
+        yearOffset: nextYearPoint.yearOffset,
+        label: nextYearPoint.label,
+        assetValueMXN,
+        rentalAccumulatedMXN,
+        valueWithRentMXN: assetValueMXN + rentalAccumulatedMXN,
+    };
+}
+export function buildAnnualPostDeliveryValueRows(projectionPoints) {
+    const deliveryPoint = projectionPoints[0];
+    if (!deliveryPoint) {
+        return [];
+    }
+    return [
+        createRow(0, "Año 0", deliveryPoint, deliveryPoint),
+        ...projectionPoints
+            .slice(1)
+            .map((point, index) => createRow(index + 1, `Año ${point.yearOffset}`, projectionPoints[index], point)),
+    ];
+}
+export function buildQuarterlyPostDeliveryValueRows(projectionPoints) {
+    const rows = [];
+    let previousQuarterPoint = projectionPoints[0];
+    if (!previousQuarterPoint) {
+        return rows;
+    }
+    for (let yearIndex = 1; yearIndex < projectionPoints.length; yearIndex += 1) {
+        const previousYearPoint = projectionPoints[yearIndex - 1];
+        const nextYearPoint = projectionPoints[yearIndex];
+        for (let quarter = 1; quarter <= 4; quarter += 1) {
+            const periodIndex = (yearIndex - 1) * 4 + quarter;
+            const currentQuarterPoint = getInterpolatedPoint(previousYearPoint, nextYearPoint, quarter / 4);
+            rows.push(createRow(periodIndex, `Año ${nextYearPoint.yearOffset} · T${quarter}`, previousQuarterPoint, currentQuarterPoint));
+            previousQuarterPoint = currentQuarterPoint;
+        }
+    }
+    return rows;
+}

package/dist/product-types.d.ts

@@ -0,0 +1,16 @@
+import type { InventoryCategory, InventoryUnit, ProductType } from "./types.js";
+type InventoryUnitSortTarget = {
+    id: string;
+    unitNumber: string;
+    name?: string;
+};
+export declare function buildInventoryUnitName(productTypeName: string, unitNumber: string): string;
+export declare function flattenProductTypes(productTypes: ProductType[]): InventoryUnit[];
+export declare function compareInventoryUnitsByName(left: InventoryUnitSortTarget, right: InventoryUnitSortTarget): number;
+export declare function sortInventoryUnitsByName<T extends InventoryUnitSortTarget>(units: readonly T[]): T[];
+export declare function getCategoryProductTypes(productTypes: ProductType[], category: InventoryCategory): ProductType[];
+export declare function getInventoryUnitsForCategory(productTypes: ProductType[], category: InventoryCategory): InventoryUnit[];
+export declare function getInventoryUnitShortLabel(unit: Pick<InventoryUnit, "unitNumber">): string;
+export declare function getInventoryUnitDetailLabel(unit: Pick<InventoryUnit, "productTypeName" | "unitNumber">): string;
+export declare function getInventoryShapeSuggestionLabels(unit: Pick<InventoryUnit, "unitNumber" | "name" | "productTypeName">): string[];
+export {};

package/dist/product-types.js

@@ -0,0 +1,82 @@
+const inventoryUnitLabelCollator = new Intl.Collator("es-MX", {
+    numeric: true,
+    sensitivity: "base",
+});
+function normalizeComparableLabel(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, " ");
+}
+export function buildInventoryUnitName(productTypeName, unitNumber) {
+    const normalizedProductTypeName = normalizeComparableLabel(productTypeName);
+    const normalizedUnitNumber = normalizeComparableLabel(unitNumber);
+    if (normalizedUnitNumber.length === 0 ||
+        normalizedUnitNumber === normalizedProductTypeName ||
+        normalizedUnitNumber.includes(normalizedProductTypeName) ||
+        normalizedProductTypeName.includes(normalizedUnitNumber)) {
+        return unitNumber;
+    }
+    return `${unitNumber} · ${productTypeName}`;
+}
+export function flattenProductTypes(productTypes) {
+    return productTypes.flatMap((productType) => productType.inventory.map((unit) => ({
+        id: unit.id,
+        unitNumber: unit.unitNumber,
+        name: buildInventoryUnitName(productType.name, unit.unitNumber),
+        productTypeId: productType.id,
+        productTypeName: productType.name,
+        category: productType.category,
+        areaM2: unit.areaM2,
+        pricePerM2MXN: unit.pricePerM2MXN,
+        deliveryDate: productType.deliveryDate,
+        allowedSchemeIds: productType.allowedSchemeIds,
+        defaultSchemeId: productType.defaultSchemeId,
+        inventoryMode: productType.inventoryMode,
+        status: unit.status,
+        ...(unit.svgElementIds && unit.svgElementIds.length > 0
+            ? { svgElementIds: unit.svgElementIds }
+            : {}),
+        ...(unit.svgPath ? { svgPath: unit.svgPath } : {}),
+    })));
+}
+function getInventoryUnitSortLabel(unit) {
+    const unitNumber = unit.unitNumber.trim();
+    if (unitNumber.length > 0) {
+        return unitNumber;
+    }
+    return unit.name?.trim() ?? "";
+}
+export function compareInventoryUnitsByName(left, right) {
+    const labelComparison = inventoryUnitLabelCollator.compare(getInventoryUnitSortLabel(left), getInventoryUnitSortLabel(right));
+    if (labelComparison !== 0) {
+        return labelComparison;
+    }
+    const leftName = left.name?.trim() ?? "";
+    const rightName = right.name?.trim() ?? "";
+    const nameComparison = inventoryUnitLabelCollator.compare(leftName, rightName);
+    if (nameComparison !== 0) {
+        return nameComparison;
+    }
+    return inventoryUnitLabelCollator.compare(left.id, right.id);
+}
+export function sortInventoryUnitsByName(units) {
+    return units.toSorted(compareInventoryUnitsByName);
+}
+export function getCategoryProductTypes(productTypes, category) {
+    return productTypes.filter((productType) => productType.category === category);
+}
+export function getInventoryUnitsForCategory(productTypes, category) {
+    return sortInventoryUnitsByName(flattenProductTypes(getCategoryProductTypes(productTypes, category)));
+}
+export function getInventoryUnitShortLabel(unit) {
+    return unit.unitNumber;
+}
+export function getInventoryUnitDetailLabel(unit) {
+    return buildInventoryUnitName(unit.productTypeName, unit.unitNumber);
+}
+export function getInventoryShapeSuggestionLabels(unit) {
+    return Array.from(new Set([unit.unitNumber, unit.name, unit.productTypeName].filter(Boolean)));
+}

package/dist/query-state.d.ts

@@ -0,0 +1,5 @@
+import type { FinanceRules, InventoryUnit, PaymentSchemeDefinition, QuoteUrlState } from "./types.js";
+export declare function normalizeQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
+export declare function normalizeSocialQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
+export declare function normalizeUondrQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
+export declare function buildQuoteSearch(state: QuoteUrlState): string;

package/dist/query-state.js

@@ -0,0 +1,157 @@
+import { clampToRange, getDefaultDownPaymentPctForScheme, getResolvedSchemeForUnit, isInstallmentScheme, } from "./payment-schemes.js";
+import { clampUondrCashbackDownPaymentPct } from "./social-quote.js";
+import { clampInstallmentDownPaymentPct, clampInstallmentMonthlyPct, INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT, INSTALLMENT_DEFAULT_MONTHLY_PCT, } from "./installment-allocation.js";
+function parseNumberParam(value, fallback) {
+    if (value === null) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? fallback : parsed;
+}
+function parseBooleanParam(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (value === 1) {
+            return true;
+        }
+        if (value === 0) {
+            return false;
+        }
+    }
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "si", "con"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "sin"].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function getStringParam(value) {
+    return typeof value === "string" ? value : null;
+}
+function getNumericParam(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return null;
+}
+function pickStringParam(...values) {
+    for (const value of values) {
+        const result = getStringParam(value);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return null;
+}
+function pickNumericParam(...values) {
+    for (const value of values) {
+        const result = getNumericParam(value);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return null;
+}
+function isCategory(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function normalizeQuoteUrlState(search, units, rules, paymentSchemes) {
+    const requestedUnitId = pickStringParam(search.unitId, search.unit);
+    const requestedCategoryParam = getStringParam(search.category);
+    const requestedScheme = getStringParam(search.scheme);
+    const defaultUnit = units.find((unit) => unit.id === rules.defaults.unitId) ??
+        units.find((unit) => unit.category === rules.defaults.category) ??
+        units[0];
+    const requestedUnit = units.find((unit) => unit.id === requestedUnitId) ?? null;
+    const requestedCategory = isCategory(requestedCategoryParam)
+        ? requestedCategoryParam
+        : (requestedUnit?.category ??
+            (isCategory(rules.defaults.category)
+                ? rules.defaults.category
+                : (defaultUnit?.category ?? "")));
+    const resolvedCategory = units.some((unit) => unit.category === requestedCategory)
+        ? requestedCategory
+        : (defaultUnit?.category ?? "");
+    const selectedUnit = requestedUnit && requestedUnit.category === resolvedCategory
+        ? requestedUnit
+        : null;
+    const schemeSourceUnit = selectedUnit ??
+        (defaultUnit?.category === resolvedCategory ? defaultUnit : null);
+    const resolvedScheme = schemeSourceUnit
+        ? getResolvedSchemeForUnit(schemeSourceUnit, paymentSchemes, requestedScheme)
+        : (paymentSchemes.find((scheme) => scheme.id === requestedScheme && scheme.active) ??
+            paymentSchemes.find((scheme) => scheme.id === rules.defaults.schemeId && scheme.active) ??
+            paymentSchemes.find((scheme) => scheme.active) ??
+            null);
+    const defaultDownPaymentPct = getDefaultDownPaymentPctForScheme(resolvedScheme, rules);
+    return {
+        category: resolvedCategory,
+        unitId: selectedUnit?.id ?? "",
+        scheme: resolvedScheme?.id ?? rules.defaults.schemeId,
+        postDeliveryYears: clampToRange(parseNumberParam(pickNumericParam(search.postDeliveryYears, search.years), rules.defaults.postDeliveryYears), rules.ranges.postDeliveryYears),
+        downPaymentPct: resolvedScheme?.type === "cashback"
+            ? clampToRange(parseNumberParam(pickNumericParam(search.downPaymentPct, search.enganche), defaultDownPaymentPct), resolvedScheme.downPaymentRange)
+            : defaultDownPaymentPct,
+        installmentDownPaymentPct: (() => {
+            const value = clampInstallmentDownPaymentPct(parseNumberParam(pickNumericParam(search.installmentDownPaymentPct, search.iEng), INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT));
+            return value;
+        })(),
+        installmentMonthlyPct: (() => {
+            const downValue = clampInstallmentDownPaymentPct(parseNumberParam(pickNumericParam(search.installmentDownPaymentPct, search.iEng), INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT));
+            return clampInstallmentMonthlyPct(parseNumberParam(pickNumericParam(search.installmentMonthlyPct, search.iMens), INSTALLMENT_DEFAULT_MONTHLY_PCT), downValue);
+        })(),
+        includeIva: parseBooleanParam(search.includeIva ?? search.iva, false),
+    };
+}
+export function normalizeSocialQuoteUrlState(search, units, rules, paymentSchemes) {
+    const state = normalizeQuoteUrlState(search, units, rules, paymentSchemes);
+    const selectedUnit = units.find((unit) => unit.id === state.unitId) ?? null;
+    const resolvedScheme = selectedUnit
+        ? getResolvedSchemeForUnit(selectedUnit, paymentSchemes, state.scheme)
+        : (paymentSchemes.find((scheme) => scheme.id === state.scheme && scheme.active) ?? null);
+    return {
+        ...state,
+        postDeliveryYears: rules.defaults.postDeliveryYears,
+        downPaymentPct: resolvedScheme && isInstallmentScheme(resolvedScheme)
+            ? resolvedScheme.downPaymentPct
+            : getDefaultDownPaymentPctForScheme(resolvedScheme, rules),
+        includeIva: false,
+    };
+}
+export function normalizeUondrQuoteUrlState(search, units, rules, paymentSchemes) {
+    const state = normalizeQuoteUrlState(search, units, rules, paymentSchemes);
+    const selectedUnit = units.find((unit) => unit.id === state.unitId) ?? null;
+    const resolvedScheme = selectedUnit
+        ? getResolvedSchemeForUnit(selectedUnit, paymentSchemes, state.scheme)
+        : (paymentSchemes.find((scheme) => scheme.id === state.scheme && scheme.active) ?? null);
+    return {
+        ...state,
+        postDeliveryYears: rules.defaults.postDeliveryYears,
+        downPaymentPct: clampUondrCashbackDownPaymentPct(resolvedScheme, state.downPaymentPct),
+        includeIva: false,
+    };
+}
+export function buildQuoteSearch(state) {
+    const params = new URLSearchParams();
+    params.set("category", state.category);
+    if (state.unitId) {
+        params.set("unit", state.unitId);
+    }
+    params.set("scheme", state.scheme);
+    params.set("years", String(state.postDeliveryYears));
+    params.set("enganche", String(state.downPaymentPct));
+    params.set("iEng", String(state.installmentDownPaymentPct));
+    params.set("iMens", String(state.installmentMonthlyPct));
+    params.set("iva", state.includeIva ? "1" : "0");
+    return params.toString();
+}