@moneylion/react-native-offer-carousel 1.10.0 → 1.10.2

package/lib/typescript/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "1.10.2";
+//# sourceMappingURL=version.d.ts.map

package/lib/typescript/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,WAAW,CAAC"}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@moneylion/react-native-offer-carousel",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "React Native components for the Engine by MoneyLion Mobile SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
-  "types": "lib/typescript/src/index.d.ts",
+  "types": "lib/typescript/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
   "files": [
@@ -30,14 +30,12 @@
   "scripts": {
     "test": "jest --silent",
     "typecheck": "tsc --noEmit",
-    "clean": "del-cli lib",
     "sync-version": "node scripts/sync-version.js",
     "prepare": "yarn sync-version && bob build"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "del-cli": "^5.1.0",
     "react-native-builder-bob": "^0.20.0",
     "type-fest": "4.26.1"
   },
@@ -61,10 +59,7 @@
     ]
   },
   "dependencies": {
-    "defu": "6.1.5",
-    "numbro": "^2.5.0",
     "radash": "11.0.0",
-    "react-native-markdown-display": "^7.0.2",
-    "ts-pattern": "5.1.1"
+    "react-native-markdown-display": "^7.0.2"
   }
 }

package/src/capabilities/configuration/src/brands/checkVisualEligibility.ts

@@ -1,6 +1,5 @@
 import { get } from "radash";
 import { enhanceType, type Brand } from "./types";
-import { match, P } from "ts-pattern";
 
 /**
  * A UI centric concept that prioritizes brands for visual use, both by the data available and the preferences of the brand.
@@ -12,18 +11,25 @@ export type VisualBrandKind = "primary" | "secondary" | "none";
  * Used to rank a primary eligible brand highest if no brand prefers primary, such as a licensed brand
  * @param brand
  */
-export const checkVisualBrandEligibility = (brand: Brand) =>
-	match([enhanceType(brand), get(brand, "allowedMarks"), brand?.isLicensed])
-		.returnType<VisualBrandKind>()
-		.with(
-			[P._, P._, true],
-			["business", { logo: true, name: true }, P.any],
-			["product", { logo: true, name: true }, P.any],
-			() => "primary"
-		)
-		.with(
-			["individual", P._, P.any],
-			["business", { name: true, logo: false }, P.any],
-			() => "secondary"
-		)
-		.otherwise(() => "none");
+export const checkVisualBrandEligibility = (brand: Brand): VisualBrandKind => {
+	const type = enhanceType(brand);
+	const allowedMarks = get<{ logo?: boolean; name?: boolean } | undefined>(
+		brand,
+		"allowedMarks"
+	);
+
+	const hasFullMarks =
+		allowedMarks?.logo === true && allowedMarks?.name === true;
+	const hasNameOnlyMarks =
+		allowedMarks?.logo === false && allowedMarks?.name === true;
+
+	if (brand?.isLicensed === true) return "primary";
+	if ((type === "business" || type === "product") && hasFullMarks) {
+		return "primary";
+	}
+
+	if (type === "individual") return "secondary";
+	if (type === "business" && hasNameOnlyMarks) return "secondary";
+
+	return "none";
+};

package/src/capabilities/configuration/src/brands/createDerivedBrands.ts

@@ -1,9 +1,17 @@
 import { isObject, sift } from "radash";
 import type { Brand } from "../../../../builder";
-import { P, match } from "ts-pattern";
 import { enhanceType } from "./types";
 import { checkVisualBrandEligibility } from "./checkVisualEligibility";
 
+const resolveLicensedBrand = (brand: Brand): Brand => {
+	if (enhanceType(brand) === "licensed") return brand;
+
+	const candidate = brand?.isLicensed || brand?.licensedBrand;
+	if (isObject(candidate)) return candidate as Brand;
+
+	throw new Error("Missing Licensed Brand");
+};
+
 /**
  * Extracts and normalizes a brand into -
  * LicensedBrand - The brand to be used for terms, legal and other compliance needs
@@ -11,29 +19,8 @@ import { checkVisualBrandEligibility } from "./checkVisualEligibility";
  * @param brand
  */
 export const createDerivedBrands = (brand: Brand) => {
-	// Determine the licensed brand for this brand, keeping in mind that this brand may be the licensed brand
-	const licensedBrand = match([
-		enhanceType(brand),
-		brand?.isLicensed || brand?.licensedBrand,
-	])
-		// Ensure we get back a brand at the end
-		.returnType<Brand>()
-		// If the type is licensed, return this brand
-		.with(["licensed", P._], () => brand)
-		// If the type is not licensed, but there is a cobrand setup, use that to get the licensed brand
-		.with(
-			[P.not("licensed"), P.select("licensedBrandObj")],
-			({ licensedBrandObj }) => {
-				if (isObject(licensedBrandObj)) return licensedBrandObj;
-				// Throw if no licensed brand is able to be found
-				throw new Error("Missing Licensed Brand");
-			}
-		)
-		.otherwise(() => {
-			throw new Error("Missing Licensed Brand");
-		});
+	const licensedBrand = resolveLicensedBrand(brand);
 
-	// Determine the set of visual brands which should be displayed on the page
 	const brandCanBeShown = checkVisualBrandEligibility(brand) !== "none";
 	return Array.from(new Set(sift([licensedBrand, brandCanBeShown && brand])));
 };

package/src/capabilities/offer-catalog/src/utils/formatUtils.ts

@@ -1,4 +1,30 @@
-import numbro from "numbro";
+const formatNumberWithMantissa = (
+	value: number,
+	mantissa: number,
+	trimMantissa: boolean,
+	thousandSeparated: boolean
+): string => {
+	let str = value.toFixed(mantissa);
+
+	if (trimMantissa && str.includes(".")) {
+		str = str.replace(/0+$/, "").replace(/\.$/, "");
+	}
+
+	if (thousandSeparated) {
+		const [intPart, decPart] = str.split(".");
+		const withCommas = (intPart ?? "").replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+		str = decPart !== undefined ? `${withCommas}.${decPart}` : withCommas;
+	}
+
+	return str;
+};
+
+const COMPACT_UNITS = [
+	{ threshold: 1e12, suffix: "T" },
+	{ threshold: 1e9, suffix: "B" },
+	{ threshold: 1e6, suffix: "M" },
+	{ threshold: 1e3, suffix: "K" },
+] as const;
 
 /**
  * Format the amount
@@ -25,15 +51,14 @@ export const formatAmount = (amount?: number, raw?: boolean): string => {
 		? (Math.ceil(amount / 1000000) * 1000000) / 100 // Round to nearest million if large
 		: amount / 100;
 
-	// Format the amount in dollars
-	const formattedAmount = numbro(amountInDollars).formatCurrency({
-		average: amountInDollars >= 1000,
-		mantissa: amountInDollars < 1000 ? 2 : 1,
-		trimMantissa: !(amount < 100 && amount !== 0),
-		spaceSeparated: false,
-	});
+	const mantissa = amountInDollars < 1000 ? 2 : 1;
+	const trimMantissa = !(amount < 100 && amount !== 0);
 
-	return formattedAmount.toUpperCase();
+	const unit = COMPACT_UNITS.find((u) => amountInDollars >= u.threshold);
+	const scaled = unit ? amountInDollars / unit.threshold : amountInDollars;
+	const suffix = unit?.suffix ?? "";
+
+	return `$${formatNumberWithMantissa(scaled, mantissa, trimMantissa, false)}${suffix}`.toUpperCase();
 };
 
 /**
@@ -51,10 +76,7 @@ export const formatAmount = (amount?: number, raw?: boolean): string => {
 export const formatPercentage = (percentage?: number): string => {
 	if (percentage === undefined || percentage === null) return "N/A";
 
-	return `${numbro(percentage / 100).format({
-		mantissa: 2,
-		trimMantissa: true,
-	})}%`;
+	return `${formatNumberWithMantissa(percentage / 100, 2, true, false)}%`;
 };
 
 /**
@@ -103,13 +125,10 @@ const formatAmountUnabbreviated = (amount?: number, raw?: boolean): string => {
 	const amountInDollars = isLargeAmount
 		? (Math.ceil(amount / 1000000) * 1000000) / 100 // Round to nearest million if large
 		: amount / 100;
+	const mantissa = amountInDollars < 1000 ? 2 : 1;
+	const trimMantissa = !(amount < 100 && amount !== 0);
 	// Format the amount in dollars
-	const formattedAmount = numbro(amountInDollars).formatCurrency({
-		mantissa: amountInDollars < 1000 ? 2 : 1,
-		trimMantissa: !(amount < 100 && amount !== 0),
-		spaceSeparated: false,
-		thousandSeparated: true,
-	});
+	const formattedAmount = `$${formatNumberWithMantissa(amountInDollars, mantissa, trimMantissa, true)}`;
 
 	return formattedAmount.toUpperCase();
 };

package/src/capabilities/offer-catalog/src/utils/stats/formatters/annualFee.ts

@@ -1,5 +1,4 @@
 import { get } from "radash";
-import { P, match } from "ts-pattern";
 import type { StatElementProps } from "../types";
 import { formatAmount, formatRange } from "../../formatUtils";
 import type { BaseOffer } from "../../../types/offerCatalogSchema";
@@ -21,56 +20,30 @@ const determineContent = ({
 	annualIntroFeeTermValue,
 	raw,
 }: {
-	annualFeeValue?: string;
 	minAnnualFeeValue?: number;
 	maxAnnualFeeValue?: number;
 	annualIntroFeeValue?: number;
 	annualIntroFeeTermValue?: number;
 	raw: boolean;
-}) => {
-	return match({
-		minAnnualFeeValue,
-		maxAnnualFeeValue,
-		annualIntroFeeValue,
-		annualIntroFeeTermValue,
-	})
-		.with(
-			{ annualIntroFeeValue: P.not(undefined) },
-			({
-				annualIntroFeeValue,
-				annualIntroFeeTermValue,
-				minAnnualFeeValue,
-				maxAnnualFeeValue,
-			}) => {
-				const postIntroFee = formatRange(
-					minAnnualFeeValue,
-					maxAnnualFeeValue,
-					"amount"
-				);
-				return `${formatAmount(
-					annualIntroFeeValue
-				)} for ${annualIntroFeeTermValue} years, then ${postIntroFee}`;
-			}
-		)
-		.with(
-			{
-				minAnnualFeeValue: P.not(undefined),
-				maxAnnualFeeValue: P.not(undefined),
-			},
-			({ minAnnualFeeValue, maxAnnualFeeValue }) => {
-				if (minAnnualFeeValue === maxAnnualFeeValue) {
-					return formatAmount(minAnnualFeeValue, raw);
-				}
-				return formatRange(minAnnualFeeValue, maxAnnualFeeValue, "amount");
-			}
-		)
-		.with({ minAnnualFeeValue: P.not(undefined) }, ({ minAnnualFeeValue }) =>
-			formatAmount(minAnnualFeeValue)
-		)
-		.with({ maxAnnualFeeValue: P.not(undefined) }, ({ maxAnnualFeeValue }) =>
-			formatAmount(maxAnnualFeeValue)
-		)
-		.otherwise(() => "See Terms");
+}): string => {
+	if (annualIntroFeeValue !== undefined) {
+		const postIntroFee = formatRange(
+			minAnnualFeeValue,
+			maxAnnualFeeValue,
+			"amount"
+		);
+		return `${formatAmount(annualIntroFeeValue)} for ${annualIntroFeeTermValue} years, then ${postIntroFee}`;
+	}
+	if (minAnnualFeeValue !== undefined && maxAnnualFeeValue !== undefined) {
+		if (minAnnualFeeValue === maxAnnualFeeValue) {
+			return formatAmount(minAnnualFeeValue, raw);
+		}
+		return formatRange(minAnnualFeeValue, maxAnnualFeeValue, "amount");
+	}
+
+	const fee = minAnnualFeeValue ?? maxAnnualFeeValue;
+	if (fee !== undefined) return formatAmount(fee);
+	return "See Terms";
 };
 
 export const annualFee =

package/src/capabilities/offer-catalog/src/utils/stats/formatters/purchaseApr.ts

@@ -1,5 +1,4 @@
 import { get } from "radash";
-import { P, match } from "ts-pattern";
 import type { StatElementProps } from "../types";
 import { formatRange } from "../../formatUtils";
 import type { BaseOffer } from "../../../types/offerCatalogSchema";
@@ -33,21 +32,14 @@ const determineContent = ({
 	purchaseAprValue?: string;
 	minPurchaseAprValue?: number;
 	maxPurchaseAprValue?: number;
-}) => {
-	return match({ purchaseAprValue, minPurchaseAprValue, maxPurchaseAprValue })
-		.with(
-			{ purchaseAprValue: P.not(undefined) },
-			({ purchaseAprValue }) => purchaseAprValue
-		)
-		.with(
-			{
-				minPurchaseAprValue: P.not(undefined),
-				maxPurchaseAprValue: P.not(undefined),
-			},
-			({ minPurchaseAprValue, maxPurchaseAprValue }) =>
-				formatRange(minPurchaseAprValue, maxPurchaseAprValue, "percentage")
-		)
-		.otherwise(() => "See Terms");
+}): string => {
+	if (purchaseAprValue !== undefined) {
+		return purchaseAprValue;
+	}
+	if (minPurchaseAprValue !== undefined && maxPurchaseAprValue !== undefined) {
+		return formatRange(minPurchaseAprValue, maxPurchaseAprValue, "percentage");
+	}
+	return "See Terms";
 };
 
 /**
@@ -56,11 +48,15 @@ const determineContent = ({
  * @param label {string}
  * @returns {string}
  */
-const determineLabel = (aprType: string, label: string) => {
-	return match(aprType)
-		.with("variable", () => "Variable APR:")
-		.with("fixed", () => "Fixed APR:")
-		.otherwise(() => label);
+const determineLabel = (aprType: string, label: string): string => {
+	switch (aprType) {
+		case "variable":
+			return "Variable APR:";
+		case "fixed":
+			return "Fixed APR:";
+		default:
+			return label;
+	}
 };
 
 export const purchaseApr =

package/src/capabilities/offer-catalog/src/utils/stats/formatters/recommendedCredit.ts

@@ -1,5 +1,4 @@
 import { get } from "radash";
-import { P, match } from "ts-pattern";
 import type { StatElementProps } from "../types";
 import { formatStringListWithAnd } from "../../formatUtils";
 import type { BaseOffer } from "../../../types/offerCatalogSchema";
@@ -28,13 +27,17 @@ export const recommendedCredit =
 	({ label, fieldName }: RecommendedCreditStat): StatElementProps => {
 		const recommendedCreditValue = get<string[]>(offer, fieldName);
 
-		const content = match(recommendedCreditValue)
-			.with(P.array(), (value) =>
-				hasAllRecommendedRatings(value)
-					? "Any"
-					: formatStringListWithAnd(orderRecommendedRatings(value))
-			)
-			.otherwise(() => "See Terms");
+		let content = "See Terms";
+
+		if (Array.isArray(recommendedCreditValue)) {
+			if (hasAllRecommendedRatings(recommendedCreditValue)) {
+				content = "Any";
+			} else {
+				content = formatStringListWithAnd(
+					orderRecommendedRatings(recommendedCreditValue)
+				);
+			}
+		}
 
 		return {
 			label,

package/src/capabilities/offer-catalog/src/utils/stats/index.ts

@@ -1,5 +1,3 @@
-import { match } from "ts-pattern";
-
 import {
 	annualFee,
 	creditBureaus,
@@ -29,113 +27,46 @@ export const statsToElementPropsBuilder = (
 	offer: BaseOffer
 ): StatElementProps[] =>
 	stats
-		.map((stat) =>
-			match(stat)
-				.with(
-					{
-						format: "rangeCurrency",
-					},
-					fromRangeCurrencyStat(offer)
-				)
-				.with(
-					{
-						format: "rangeCurrencyUnabbreviated",
-					},
-					fromRangeCurrencyUnabbreviatedStat(offer)
-				)
-				.with(
-					{
-						format: "BureausStat",
-					},
-					creditBureaus(offer)
-				)
-				.with(
-					{
-						format: "rangePercent",
-					},
-					fromRangePercentStat(offer)
-				)
-				.with(
-					{
-						format: "rangeCurrencyOrBasis",
-					},
-					fromRangeCurrencyOrBasisStat(offer)
-				)
-				.with(
-					{
-						format: "common",
-					},
-					fromCommonStat(offer)
-				)
-				.with(
-					{
-						format: "rangeCurrencyByTime",
-					},
-					fromRangeCurrencyByTimeStat(offer)
-				)
-				.with(
-					{
-						format: "freeTrial",
-					},
-					fromFreeTrialStat(offer)
-				)
-				.with(
-					{
-						format: "monthlyOrAnnualCurrency",
-					},
-					fromMonthlyOrAnnualCurrencyStat(offer)
-				)
-				.with(
-					{
-						format: "boolean",
-					},
-					fromBooleanStat(offer)
-				)
-				.with({ format: "rangeMonths" }, fromRangeMonthsStat(offer))
-				.with(
-					{
-						format: "listStringWithAnd",
-					},
-					fromListStringWithAnd(offer)
-				)
-				.with(
-					{
-						format: "currency",
-					},
-					fromCurrencyStat(offer)
-				)
-				.with(
-					{
-						format: "percentage",
-					},
-					fromPercentageStat(offer)
-				)
-				.with(
-					{
-						format: "recommendedCredit",
-					},
-					recommendedCredit(offer)
-				)
-				.with(
-					{
-						format: "rewardsDisplay",
-					},
-					rewardsDisplay(offer)
-				)
-				.with(
-					{
-						format: "purchaseApr",
-					},
-					purchaseApr(offer)
-				)
-				.with(
-					{
-						format: "annualFee",
-					},
-					annualFee(offer)
-				)
-				.exhaustive()
-		)
+		.map((stat): StatElementProps => {
+			switch (stat.format) {
+				case "rangeCurrency":
+					return fromRangeCurrencyStat(offer)(stat);
+				case "rangeCurrencyUnabbreviated":
+					return fromRangeCurrencyUnabbreviatedStat(offer)(stat);
+				case "BureausStat":
+					return creditBureaus(offer)(stat);
+				case "rangePercent":
+					return fromRangePercentStat(offer)(stat);
+				case "rangeCurrencyOrBasis":
+					return fromRangeCurrencyOrBasisStat(offer)(stat);
+				case "common":
+					return fromCommonStat(offer)(stat);
+				case "rangeCurrencyByTime":
+					return fromRangeCurrencyByTimeStat(offer)(stat);
+				case "freeTrial":
+					return fromFreeTrialStat(offer)(stat);
+				case "monthlyOrAnnualCurrency":
+					return fromMonthlyOrAnnualCurrencyStat(offer)(stat);
+				case "boolean":
+					return fromBooleanStat(offer)(stat);
+				case "rangeMonths":
+					return fromRangeMonthsStat(offer)(stat);
+				case "listStringWithAnd":
+					return fromListStringWithAnd(offer)(stat);
+				case "currency":
+					return fromCurrencyStat(offer)(stat);
+				case "percentage":
+					return fromPercentageStat(offer)(stat);
+				case "recommendedCredit":
+					return recommendedCredit(offer)(stat);
+				case "rewardsDisplay":
+					return rewardsDisplay(offer)(stat);
+				case "purchaseApr":
+					return purchaseApr(offer)(stat);
+				case "annualFee":
+					return annualFee(offer)(stat);
+			}
+		})
 		.filter((stat) => stat !== null);
 
 export type { Stat, StatElementProps } from "./types";

package/src/capabilities/offers/pipeline/src/sources/ratetables/withDeviceSignals.ts

@@ -1,4 +1,3 @@
-import defu from "defu";
 import { get, mapValues } from "radash";
 import { createDerivedBrands } from "../../../../../configuration/src/brands/createDerivedBrands";
 import type { CnfContext } from "../../../../../core/src/system/cnfContext/CnfContext";
@@ -63,21 +62,31 @@ export function withDeviceSignals<
 		cnfEnvironment,
 	};
 
-	return defu(payload, {
-		/**
-		 * The leads API required device ID's be in the UUID format. If the string
-		 * we receive here is not in the expected format, we will create an error
-		 * passing it to the API.
-		 */
+	// all clientTag values must be arrays of strings
+	const toStringArray = (value: unknown): string[] =>
+		Array.isArray(value) ? value.map(String) : [String(value)];
+
+	const defaultClientTags = mapValues(clientTags, toStringArray);
+	const payloadClientTags = mapValues(
+		(payload.clientTags ?? {}) as Record<string, unknown>,
+		toStringArray
+	);
+
+	const mergedClientTags: Record<string, string[]> = { ...defaultClientTags };
+	for (const [key, value] of Object.entries(payloadClientTags)) {
+		const existing = mergedClientTags[key];
+		mergedClientTags[key] = existing ? [...value, ...existing] : value;
+	}
+
+	/**
+	 * The leads API requires device IDs be in the UUID format. If the string
+	 * we receive here is not in the expected format, we omit it so the API can
+	 * reject the request explicitly.
+	 */
+	return {
 		deviceId: isUUIDv4(maybeDeviceId) ? maybeDeviceId : undefined,
-		sessionInformation: {
-			ipAddress,
-			userAgent,
-		},
-		clientTags: mapValues(
-			clientTags,
-			// all values must be arrays of strings
-			(value) => (Array.isArray(value) ? value.map(String) : [String(value)])
-		),
-	});
+		sessionInformation: { ipAddress, userAgent },
+		...payload,
+		clientTags: mergedClientTags,
+	};
 }