@moneylion/react-native-offer-carousel 1.0.0 → 1.0.1

package/src/capabilities/offer-catalog/src/types/offerCatalogSchema.ts

@@ -0,0 +1,119 @@
+export type BaseOffer = {
+	productVersions: number[];
+	uuid: string;
+	version: number;
+	url: string;
+	financialInstitutionUuid: string;
+	createdAt: string;
+	internalName: string;
+	legalLanguage?: string;
+	unmonetizedUrl: string;
+	recommendationScore: number;
+	productDisplayName: string;
+	productType: string;
+	financialInstitutionImageUrl: string;
+	status: "active" | "inactive" | "pending";
+	updatedAt: string;
+	financialInstitutionDisplayName: string;
+	keywords?: string[];
+	acceptanceRequirements?: string;
+	headline?: string;
+	monetizedUrl?: string;
+	disclaimer?: string;
+	firmness?: string;
+	annualPercentageRateType?: "fixed" | "variable";
+	annualPercentageRateBasisPointsMax?: number;
+	annualPercentageRateBasisPointsMin?: number;
+	amountCentsMax?: number;
+	amountCentsMin?: number;
+	description?: string;
+	descriptionPoints?: string[];
+	monthlyPaymentCentsMin?: number;
+	monthlyPaymentCentsMax?: number;
+	creditBureauReporting?: string[];
+	stateExclusions?: string[];
+	enrollmentFeeBasisPointsMax?: number;
+	enrollmentFeeBasisPointsMin?: number;
+	debtAmountCentsMin?: number;
+	debtAmountCentsMax?: number;
+	monthlyFeeCentsMin?: number;
+	monthlyFeeCentsMax?: number;
+	fastTransferFeeCentsMin?: number;
+	fastTransferFeeCentsMax?: number;
+	fastTransferFeeBasisPointsMin?: number;
+	fastTransferFeeBasisPointsMax?: number;
+	annualAdvisoryFeeBasisPointsMin?: number;
+	annualAdvisoryFeeBasisPointsMax?: number;
+	accountCentsMin?: number;
+	termLengthMonthsMin?: number;
+	termLengthMonthsMax?: number;
+	demandSubAccountUuid?: string;
+	demandSubAccountImageUrl?: string;
+	demandSubAccountDisplayName?: string;
+	outOfNetworkAtmUsageFeeCents?: number;
+	annualPercentageYieldBasisPoints?: number;
+	isMonetized?: boolean;
+	overrideUrl?: string;
+};
+export type DemandPartner = {
+	uuid: string;
+	name: string;
+	description: string;
+	disclaimer: string;
+	supportsPreSelect: boolean;
+	shouldDisplayPreSelect: boolean;
+	supportsPersonalizedOffers: boolean;
+	imageUrl: string;
+	subtextOverride?: string;
+};
+
+export type BasicRateTablePendingResponse = {
+	partner: DemandPartner;
+	offerCatalogProductTypes: string[];
+};
+
+export type ProductTypes =
+	| "CreditBuilderLoan"
+	| "DebtSettlement"
+	| "HomeEquityLineOfCredit"
+	| "RoboInvesting"
+	| "StudentLoanRefinance"
+	| "IncomeOpportunities"
+	| "CashManagementAccount"
+	| "HomeEquityLoan"
+	| "StudentLoan"
+	| "CashAdvance"
+	| "EarnedWageAccess"
+	| "RoboInvesting"
+	| "StudentLoanRefinance"
+	| "StudentLoan"
+	| "AutomobileLoan"
+	| "AutomobileRefinance"
+	| "UnsecuredPersonalLoan"
+	| "SecuredPersonalLoan"
+	| "UnsecuredLineOfCredit"
+	| "OverdraftProtection"
+	| "CreditBuilderSecuredCreditCard"
+	| "CreditBuilderDebitCard"
+	| "RentUtilityBillReporting"
+	| (string & {});
+
+export type OffersData = {
+	isError?: boolean;
+	uuid: string;
+	leadUuid: string;
+	offers: BaseOffer[];
+	pendingResponses?: BasicRateTablePendingResponse[];
+};
+
+export type ProductTypeDefinition = {
+	id: string;
+	partnerPageUrl: string;
+	productTypeSlug: string;
+};
+
+export type PartnerOverride = {
+	id: string;
+	overrideUrl: string;
+	financialInstitutionUuid: string;
+};

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

@@ -0,0 +1,3 @@
+export const arrayToMarkdownList = (arr: string[]) => {
+	return arr?.map((item) => `- ${item}`).join("\n");
+};

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

@@ -0,0 +1,73 @@
+import type { CnfContext } from "../../../core/src/system/cnfContext/CnfContext";
+
+const STATE_CODE_FALLBACK = "NY";
+
+export const getStateCode = (cnfContext: CnfContext) => {
+	const stateCode = cnfContext.signals.deviceSignals?.state?.code;
+
+	if (!stateCode) {
+		console.warn(stateCode, "state code not found in getCNFContext");
+	}
+
+	return stateCode || STATE_CODE_FALLBACK;
+};
+
+export const getSubaccountToken = (cnfContext: CnfContext) =>
+	cnfContext.subaccount.publicToken;
+
+export const parseClientTags = (tags?: string) => {
+	if (!tags) {
+		return {};
+	}
+
+	// Decode the tags to handle special characters
+	const decodedTags = decodeURIComponent(tags);
+
+	const clientTags = decodedTags
+		// Split the tags by the 'tag.' prefix to get the individual tags
+		.split(/(?=(?:^|&)tag\.)/)
+		.reduce<Record<string, string[]>>((acc, tag) => {
+			// Remove the leading '&' from the tag if it exists
+			const cleanTag = tag.replace(/^&/, "");
+			// Find the index of the '=' character in the tag
+			const equalIndex = cleanTag.indexOf("=");
+
+			// If the tag is not a valid key-value pair, return the accumulator
+			if (equalIndex === -1) return acc;
+
+			// Extract the key and value from the tag
+			const key = cleanTag.substring(0, equalIndex);
+			const value = cleanTag.substring(equalIndex + 1);
+
+			// If the key starts with 'tag.', it is a valid client tag
+			if (key.startsWith("tag.")) {
+				const cleanKey = key.replace("tag.", "");
+				// Handle comma-separated or pipe-separated values
+				if (value.includes(",") || value.includes("|")) {
+					// Split the value into an array based on comma or pipe separators
+					acc[cleanKey] = value.split(/[,|]/);
+				} else {
+					// If the value is not comma or pipe separated, add it to the accumulator as a single value
+					acc[cleanKey] = [value];
+				}
+			}
+			return acc;
+		}, {});
+
+	return clientTags;
+};
+
+export const getSubAccountUUID = (cnfContext: CnfContext) => {
+	const supplySubaccountUuid = cnfContext.subaccount.supplySubaccountUuid;
+
+	if (!supplySubaccountUuid) {
+		console.warn("Supply subaccount uuid not found in context");
+	}
+
+	return supplySubaccountUuid;
+};
+
+export const getLeadUUID = (cnfContext: CnfContext) =>
+	cnfContext.signals.lead.uuid;
+
+export const getIsDevEnvironment = (cnfContext: CnfContext) => cnfContext.isDev;

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

@@ -0,0 +1,18 @@
+const errorUtil = {
+	getErrorMessageForResponseStatus(status: number, statusText: string): string {
+		return `${status}: ${statusText}`;
+	},
+	getErrorForOffersFromProductTypes(
+		error: "DEVICE_SIGNALS_ERROR" | "NO_OFFERS" | "DEFAULT"
+	): string {
+		const errorMessages = {
+			DEVICE_SIGNALS_ERROR: "Error getting device signals",
+			NO_OFFERS: "No offers found",
+			DEFAULT: "An unexpected error occurred in getOffersFromProductTypes",
+		} as const;
+
+		return errorMessages[error] || errorMessages.DEFAULT;
+	},
+};
+
+export default errorUtil;

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

@@ -0,0 +1,168 @@
+import numbro from "numbro";
+
+/**
+ * Format the amount
+ * @param amount {number | undefined} - Amount in cents
+ * @param raw {boolean | undefined} - Returns the amount in raw cents (currently only used for zero values)
+ * @returns {string}
+ * @example
+ * formatAmount(undefined)
+ * // returns 'N/A'
+ * formatAmount(0)
+ * // returns 'Free'
+ * formatAmount(1000)
+ * // returns '$10'
+ * formatAmount(100000)
+ * // returns '$1K'
+ */
+export const formatAmount = (amount?: number, raw?: boolean): string => {
+	if (Number.isNaN(amount) || amount === undefined) return "N/A";
+	if (amount === 0 && !raw) return "FREE";
+
+	// Convert cents to dollars
+	const isLargeAmount = amount >= 99999900;
+	const amountInDollars = isLargeAmount
+		? (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,
+	});
+
+	return formattedAmount.toUpperCase();
+};
+
+/**
+ * Format the percentage
+ * @param percentage {number}
+ * @returns {string}
+ * @example
+ * formatPercentage(undefined)
+ * // returns 'N/A'
+ * formatPercentage(399)
+ * // returns '3.99%'
+ * formatPercentage(1800)
+ * // returns '18%'
+ */
+export const formatPercentage = (percentage?: number): string => {
+	if (percentage === undefined || percentage === null) return "N/A";
+
+	return `${numbro(percentage / 100).format({
+		mantissa: 2,
+		trimMantissa: true,
+	})}%`;
+};
+
+/**
+ * Format the strings with commas and add '&' to the last string
+ * @param strings {string[]}
+ * @returns {string}
+ * @example
+ * addAndToLastString(['CT', 'DE', 'GA', 'HI', 'IL'])
+ * // returns 'CT, DE, GA, HI & IL'
+ */
+export const formatStringListWithAnd = (strings?: string[]): string => {
+	if (!strings?.length) {
+		return "N/A";
+	}
+	if (strings.length === 1) {
+		return strings[0] ?? "N/A";
+	}
+	const newStrings = [...strings];
+	const lastString = newStrings.pop();
+	return `${newStrings.join(", ")} & ${lastString}`;
+};
+
+/**
+ * Format the amount with unabreviated values
+ * @param amount {number | undefined} - Amount in cents
+ * @param raw {boolean | undefined} - Returns the amount in raw cents (currently only used for zero values)
+ * @returns {string}
+ * @example
+ * formatAmountUnabbreviated(undefined)
+ * // returns 'N/A'
+ * formatAmountUnabbreviated(0)
+ * // returns 'Free'
+ * formatAmountUnabbreviated(1000)
+ * // returns '$10'
+ * formatAmountUnabbreviated(100000)
+ * // returns '$1,000'
+ * formatAmountUnabbreviated(10000000)
+ * // returns '$100,000'
+ */
+const formatAmountUnabbreviated = (amount?: number, raw?: boolean): string => {
+	if (Number.isNaN(amount) || amount === undefined) return "N/A";
+	if (amount === 0 && !raw) return "FREE";
+
+	// Convert cents to dollars
+	const isLargeAmount = amount >= 99999900;
+	const amountInDollars = isLargeAmount
+		? (Math.ceil(amount / 1000000) * 1000000) / 100 // Round to nearest million if large
+		: amount / 100;
+	// Format the amount in dollars
+	const formattedAmount = numbro(amountInDollars).formatCurrency({
+		mantissa: amountInDollars < 1000 ? 2 : 1,
+		trimMantissa: !(amount < 100 && amount !== 0),
+		spaceSeparated: false,
+		thousandSeparated: true,
+	});
+
+	return formattedAmount.toUpperCase();
+};
+
+/**
+ * Format the range based on the min and max values
+ * @param min {number | undefined}
+ * @param max {number | undefined}
+ * @param type {string | undefined}
+ * @returns {string}
+ * @example
+ * formatRange(undefined, undefined)
+ * // returns 'N/A'
+ * formatRange(100, undefined)
+ * // returns 'N/A'
+ * formatRange(undefined, 100)
+ * // returns 'N/A'
+ * formatRange(0, 0)
+ * // returns 'Free'
+ * formatRange(100, 100)
+ * // returns '$1'
+ * formatRange(1000, 1000)
+ * // returns '$10'
+ * formatRange(1000, 10000)
+ * // returns '$10 - $100'
+ * formatRange(1000, 100000)
+ * // returns '$10 - $1K'
+ * formatRange(350, 490, 'percentage')
+ * // returns '3.5% - 4.9%'
+ * formatRange(1000, 10000, 'percentage')
+ * // returns '10% - 100%'
+ */
+export const formatRange = (
+	min?: number,
+	max?: number,
+	type: "amount" | "percentage" = "amount",
+	amountFormat?: "unabbreviated"
+): string => {
+	const resolvedFormatAmount =
+		amountFormat === "unabbreviated" ? formatAmountUnabbreviated : formatAmount;
+	if (min === undefined || max === undefined) return "N/A";
+
+	if (type === "percentage") {
+		return min === max
+			? formatPercentage(min)
+			: `${formatPercentage(min)} - ${formatPercentage(max)}`;
+	}
+
+	if ((min === 0 || min === 1) && max !== 0) {
+		return `Up to ${resolvedFormatAmount(max)}`;
+	}
+
+	return min === max
+		? resolvedFormatAmount(min)
+		: `${resolvedFormatAmount(min)} - ${resolvedFormatAmount(max)}`;
+};

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

@@ -0,0 +1,61 @@
+import type {
+	BaseOffer,
+	ProductTypeDefinition,
+	PartnerOverride,
+} from "../types/offerCatalogSchema";
+
+type GetOfferUrlProps = {
+	offer: BaseOffer;
+	productTypesDefinition?: ProductTypeDefinition[];
+	partnersOverrideDefinition?: PartnerOverride[];
+};
+
+type GetOfferUrlResult = {
+	url: string;
+	overrideUrl?: string | undefined;
+};
+
+/**
+ * Get the offer URL.
+ * @description
+ * Returns the offer URL and any applicable override URL based on the provided offer and definitions.
+ * Override URL determination process:
+ * 1. First checks for a product type override from productTypesDefinition
+ * 2. Then checks for a partner override from partnersOverrideDefinition (takes precedence)
+ * The base offer URL is always returned, while the override URL is optional.
+ * @param {GetOfferUrlProps} props - The properties for getting the offer URL.
+ * @returns {GetOfferUrlResult} An object containing the URL and optional override URL.
+ **/
+export const getOfferUrl = ({
+	offer,
+	productTypesDefinition,
+	partnersOverrideDefinition,
+}: GetOfferUrlProps): GetOfferUrlResult => {
+	// Start with the base result
+	const result: GetOfferUrlResult = {
+		url: offer.url,
+	};
+
+	// Check product type override first
+	const partnerPageUrl = productTypesDefinition?.find(
+		(definition) => definition.productTypeSlug === offer.productType
+	)?.partnerPageUrl;
+
+	if (partnerPageUrl) {
+		result.overrideUrl = partnerPageUrl;
+	}
+
+	if (!partnersOverrideDefinition?.length) return result;
+
+	// Check partner override second (will overwrite product type override if exists)
+	const partnerOverride = partnersOverrideDefinition?.find(
+		(partner) =>
+			partner.financialInstitutionUuid === offer.financialInstitutionUuid
+	)?.overrideUrl;
+
+	if (partnerOverride) {
+		result.overrideUrl = partnerOverride;
+	}
+
+	return result;
+};

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

@@ -0,0 +1,103 @@
+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";
+
+export type AnnualFeeStat = {
+	format: "annualFee";
+	label: string;
+	minAnnualFeeField: string;
+	maxAnnualFeeField: string;
+	annualIntroFeeField: string;
+	annualIntroFeeTermField: string;
+	raw?: boolean;
+};
+
+const determineContent = ({
+	minAnnualFeeValue,
+	maxAnnualFeeValue,
+	annualIntroFeeValue,
+	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");
+};
+
+export const annualFee =
+	(offer: BaseOffer) =>
+	({
+		label,
+		minAnnualFeeField,
+		maxAnnualFeeField,
+		annualIntroFeeField,
+		annualIntroFeeTermField,
+		raw = false,
+	}: AnnualFeeStat): StatElementProps => {
+		const minAnnualFeeValue = get<number>(offer, minAnnualFeeField);
+		const maxAnnualFeeValue = get<number>(offer, maxAnnualFeeField);
+		const annualIntroFeeValue = get<number>(offer, annualIntroFeeField);
+		const annualIntroFeeTermValue = get<number>(offer, annualIntroFeeTermField);
+
+		const content = determineContent({
+			minAnnualFeeValue,
+			maxAnnualFeeValue,
+			annualIntroFeeValue,
+			annualIntroFeeTermValue,
+			raw,
+		});
+
+		return {
+			label,
+			content,
+		};
+	};

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

@@ -0,0 +1,58 @@
+// import { describe, expect, it } from "vitest";
+// import { type BooleanStat, fromBooleanStat } from "./boolean";
+
+// describe("fromBooleanStat", () => {
+// 	it.each([
+// 		[
+// 			{ isAvailable: true },
+// 			{ format: "boolean", label: "Availability", fieldName: "isAvailable" },
+// 			{ label: "Availability", content: "True" },
+// 		],
+// 		[
+// 			{ isAvailable: false },
+// 			{ format: "boolean", label: "Availability", fieldName: "isAvailable" },
+// 			{ label: "Availability", content: "False" },
+// 		],
+// 		[
+// 			{ isAvailable: true },
+// 			{
+// 				format: "boolean",
+// 				label: "Availability",
+// 				fieldName: "isAvailable",
+// 				trueValue: "In Stock",
+// 			},
+// 			{ label: "Availability", content: "In Stock" },
+// 		],
+// 		[
+// 			{ isAvailable: false },
+// 			{
+// 				format: "boolean",
+// 				label: "Availability",
+// 				fieldName: "isAvailable",
+// 				falseValue: "Out of Stock",
+// 			},
+// 			{ label: "Availability", content: "Out of Stock" },
+// 		],
+// 		[
+// 			{},
+// 			{ format: "boolean", label: "Availability", fieldName: "isAvailable" },
+// 			{ label: "Availability", content: "False" },
+// 		],
+// 		[
+// 			{},
+// 			{
+// 				format: "boolean",
+// 				label: "Availability",
+// 				fieldName: "isAvailable",
+// 				falseValue: "Unavailable",
+// 			},
+// 			{ label: "Availability", content: "Unavailable" },
+// 		],
+// 	])(
+// 		"should return the correct content for offer %j and stat %j",
+// 		(offer, stats, expected) => {
+// 			const result = fromBooleanStat(offer as BaseOffer)(stats as BooleanStat);
+// 			expect(result).toEqual(expected);
+// 		}
+// 	);
+// });

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

@@ -0,0 +1,31 @@
+import { get } from "radash";
+import type { StatElementProps } from "../types";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+
+export type BooleanStat = {
+	format: "boolean";
+	label: string;
+	fieldName: string;
+	trueValue?: string;
+	falseValue?: string;
+};
+
+export const fromBooleanStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		fieldName,
+		falseValue,
+		trueValue,
+	}: BooleanStat): StatElementProps => {
+		const booleanValue = get(offer, fieldName, false);
+
+		const content = booleanValue
+			? (trueValue ?? "True")
+			: (falseValue ?? "False");
+
+		return {
+			label,
+			content,
+		};
+	};

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

@@ -0,0 +1,60 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { fromCommonStat } from './common'
+
+// describe('fromCommonStat', () => {
+//   it.each([
+//     [{ title: 'special offer' }, 'Offer Title', 'special offer'],
+//     [{}, 'Missing Field', ''],
+//   ])('should return the correct content for offer %j', (offer, label, content) => {
+//     const result = fromCommonStat(offer as unknown as BaseOffer)({
+//       label,
+//       fieldName: 'title',
+//       format: 'common',
+//     })
+//     expect(result).toEqual({
+//       label,
+//       content,
+//     })
+//   })
+
+//   it.each([
+//     [{ title: 'special offer' }, 'Static Value', 'Special offer'],
+//     [{ title: 'limited time only' }, 'Description', 'Limited time only'],
+//   ])(
+//     'should return the correct content for offer %j and capitalized',
+//     (offer, label, content) => {
+//       const result = fromCommonStat(offer as unknown as BaseOffer)({
+//         label,
+//         fieldName: 'title',
+//         format: 'common',
+//         capitalized: true,
+//       })
+//       expect(result).toEqual({
+//         label,
+//         content,
+//       })
+//     },
+//   )
+
+//   it.each([
+//     [{ score: 600 }, '600'],
+//     [{ score: undefined }, 'No minimum'],
+//   ])(
+//     'should return the correct content for offer %j with the default value and fieldName',
+//     (offer, content) => {
+//       const result = fromCommonStat(offer as unknown as BaseOffer)({
+//         label: 'Minimum Credit Score',
+//         fieldName: 'score',
+//         format: 'common',
+//         defaultValue: 'No minimum',
+//         capitalized: true,
+//       })
+
+//       expect(result).toEqual({
+//         label: 'Minimum Credit Score',
+//         content,
+//       })
+//     },
+//   )
+// })