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

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

@@ -0,0 +1,92 @@
+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";
+
+export type PurchaseAprStat = {
+	format: "purchaseApr";
+	label: string;
+	purchaseAprTextField: string;
+	minPurchaseAprField: string;
+	maxPurchaseAprField: string;
+	aprTypeField: string;
+};
+
+/**
+ * Determine the content of the purchaseApr stat
+ * @param params {purchaseAprValue, minPurchaseAprValue, maxPurchaseAprValue}
+ * @returns {string}
+ * @example
+ * determineContent({ purchaseAprValue: '10%', minPurchaseAprValue: null, maxPurchaseAprValue: null })
+ * // returns '10%'
+ * determineContent({ purchaseAprValue: null, minPurchaseAprValue: 5, maxPurchaseAprValue: 10 })
+ * // returns '5% - 10%'
+ * determineContent({ purchaseAprValue: null, minPurchaseAprValue: null, maxPurchaseAprValue: null })
+ * // returns 'See Terms'
+ */
+const determineContent = ({
+	purchaseAprValue,
+	minPurchaseAprValue,
+	maxPurchaseAprValue,
+}: {
+	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");
+};
+
+/**
+ * Determine the label of the purchaseApr stat
+ * @param aprType {string}
+ * @param label {string}
+ * @returns {string}
+ */
+const determineLabel = (aprType: string, label: string) => {
+	return match(aprType)
+		.with("variable", () => "Variable APR:")
+		.with("fixed", () => "Fixed APR:")
+		.otherwise(() => label);
+};
+
+export const purchaseApr =
+	(offer: BaseOffer) =>
+	({
+		label: defaultLabel,
+		purchaseAprTextField,
+		minPurchaseAprField,
+		maxPurchaseAprField,
+		aprTypeField,
+	}: PurchaseAprStat): StatElementProps => {
+		const purchaseAprValue = get<string>(offer, purchaseAprTextField);
+		const minPurchaseAprValue = get<number>(offer, minPurchaseAprField);
+		const maxPurchaseAprValue = get<number>(offer, maxPurchaseAprField);
+		const aprTypeValue = get<string>(offer, aprTypeField);
+
+		const content = determineContent({
+			purchaseAprValue,
+			minPurchaseAprValue,
+			maxPurchaseAprValue,
+		}).replace(/ Variable APR| Fixed APR/g, "");
+
+		const label = determineLabel(aprTypeValue, defaultLabel);
+
+		return {
+			label,
+			content,
+		};
+	};

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

@@ -0,0 +1,34 @@
+
+import { get } from "radash";
+import type { StatElementProps } from "../types";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+import { formatRange } from "../../formatUtils";
+
+export type RangeCurrencyStat = {
+	format: "rangeCurrency";
+	label: string;
+	initialFieldName: string;
+	endFieldName: string;
+};
+
+export const fromRangeCurrencyStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		initialFieldName,
+		endFieldName,
+	}: RangeCurrencyStat): StatElementProps => {
+		const initialValue = get<number | undefined>(
+			offer,
+			initialFieldName,
+			undefined
+		);
+		const endValue = get<number | undefined>(offer, endFieldName, undefined);
+
+		const content = formatRange(initialValue, endValue, "amount");
+
+		return {
+			label,
+			content,
+		};
+	};

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

@@ -0,0 +1,70 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { fromRangeCurrencyByTimeStat } from './rangeCurrencyByTime'
+
+// describe('fromRangeCurrencyByTimeStat', () => {
+//   it.each([
+//     // Test case: All values undefined
+//     [{}, 'Price Range', 'N/A'],
+//     // Test case: All values zero
+//     [
+//       {
+//         initialPriceByMonth: 0,
+//         endPriceByMonth: 0,
+//         initialPriceByYear: 0,
+//         endPriceByYear: 0,
+//       },
+//       'Price Range',
+//       'FREE',
+//     ],
+//     [
+//       {
+//         initialPriceByYear: 0,
+//         endPriceByYear: 0,
+//       },
+//       'Price Range',
+//       'FREE',
+//     ],
+//     [{ initialPriceByMonth: 1000 }, 'Price Range', 'N/A'],
+//     [{ endPriceByMonth: 2000 }, 'Price Range', 'N/A'],
+//     [
+//       { initialPriceByMonth: 1000, endPriceByMonth: 2000 },
+//       'Price Range',
+//       '$10 - $20 / Month',
+//     ],
+//     [{ initialPriceByYear: 500 }, 'Discount Range', 'N/A'],
+//     [{ endPriceByYear: 1500 }, 'Discount Range', 'N/A'],
+//     [
+//       { initialPriceByYear: 500, endPriceByYear: 1500 },
+//       'Discount Range',
+//       '5% - 15% / Year',
+//     ],
+//     [
+//       {
+//         initialPriceByMonth: 1000,
+//         endPriceByMonth: 2000,
+//         initialPriceByYear: 500,
+//         endPriceByYear: 1500,
+//       },
+//       'Price Range',
+//       '$10 - $20 / Month',
+//     ],
+//     [{ initialPriceByMonth: 0 }, 'Price Range', 'N/A'],
+//     [{ initialPriceByYear: 0 }, 'Price Range', 'N/A'],
+//   ])(
+//     'should return the correct content for offer %j',
+//     (offer, label, expectedContent) => {
+//       const result = fromRangeCurrencyByTimeStat(offer as BaseOffer)({
+//         format: 'rangeCurrencyByTime',
+//         label,
+//         initialFieldNameByMonths: 'initialPriceByMonth',
+//         endFieldNameByMonths: 'endPriceByMonth',
+//         initialFieldNameByYears: 'initialPriceByYear',
+//         endFieldNameByYears: 'endPriceByYear',
+//       })
+//       expect(result).toEqual({
+//         label,
+//         content: expectedContent,
+//       })
+//     },
+//   )
+// })

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

@@ -0,0 +1,71 @@
+import { get } from "radash";
+import type { StatElementProps } from "../types";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+import { formatRange } from "../../formatUtils";
+
+export type RangeCurrencyByTimeStat = {
+	format: "rangeCurrencyByTime";
+	label: string;
+	initialFieldNameByMonths: string;
+	endFieldNameByMonths: string;
+	initialFieldNameByYears: string;
+	endFieldNameByYears: string;
+};
+
+export const fromRangeCurrencyByTimeStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		initialFieldNameByMonths,
+		endFieldNameByMonths,
+		initialFieldNameByYears,
+		endFieldNameByYears,
+	}: RangeCurrencyByTimeStat): StatElementProps => {
+		const initialValueByMonths = get<number | undefined>(
+			offer,
+			initialFieldNameByMonths
+		);
+		const endValueByMonths = get<number | undefined>(
+			offer,
+			endFieldNameByMonths
+		);
+		const initialValueByYears = get<number | undefined>(
+			offer,
+			initialFieldNameByYears
+		);
+		const endValueByYears = get<number | undefined>(offer, endFieldNameByYears);
+
+		const values = [
+			initialValueByMonths,
+			endValueByMonths,
+			initialValueByYears,
+			endValueByYears,
+		];
+
+		const definedValues = values.filter((value) => value !== undefined);
+		const definedValuesCount = definedValues.length;
+
+		if (definedValuesCount < 2) {
+			return { label, content: "N/A" };
+		}
+
+		if (definedValues.every((value) => value === 0)) {
+			return { label, content: "FREE" };
+		}
+
+		const hasMonthlyValues = initialValueByMonths || endValueByMonths;
+
+		const initialValue = hasMonthlyValues
+			? initialValueByMonths
+			: initialValueByYears;
+		const endValue = hasMonthlyValues ? endValueByMonths : endValueByYears;
+		const timeUnit = hasMonthlyValues ? "/ Month" : "/ Year";
+		const formatType = hasMonthlyValues ? "amount" : "percentage";
+
+		const content = formatRange(initialValue, endValue, formatType);
+
+		return {
+			label,
+			content: `${content} ${timeUnit}`,
+		};
+	};

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

@@ -0,0 +1,27 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { fromRangeCurrencyUnabbreviatedStat } from './rangeCurrencyUnabbreviated'
+
+// describe('fromRangeCurrencyUnabbreviatedStat', () => {
+//   it.each([
+//     [{ amountCentsMin: 500, amountCentsMax: 500000 }, 'Amount', '$5 - $5,000'],
+//     [{ amountCentsMin: 0, amountCentsMax: 500000 }, 'Amount', 'Up to $5,000'],
+//     [{ amountCentsMin: 1, amountCentsMax: 500000 }, 'Amount', 'Up to $5,000'],
+//     [{ amountCentsMax: 500000 }, 'Amount', 'N/A'],
+//     [{ amountCentsMin: 5000 }, 'Amount', 'N/A'],
+//   ])(
+//     'should return correct label and content for offer %j',
+//     (offer: unknown, label: string, expectedContent: string) => {
+//       const result = fromRangeCurrencyUnabbreviatedStat(offer as BaseOffer)({
+//         format: 'rangeCurrencyUnabbreviated',
+//         label,
+//         initialFieldName: 'amountCentsMin',
+//         endFieldName: 'amountCentsMax',
+//       })
+//       expect(result).toEqual({
+//         label: 'Amount',
+//         content: expectedContent,
+//       })
+//     },
+//   )
+// })

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

@@ -0,0 +1,38 @@
+import { get } from "radash";
+import type { StatElementProps } from "../types";
+import { formatRange } from "../../formatUtils";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+
+export type RangeCurrencyUnabbreviatedStat = {
+	format: "rangeCurrencyUnabbreviated";
+	label: string;
+	initialFieldName: string;
+	endFieldName: string;
+};
+
+export const fromRangeCurrencyUnabbreviatedStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		initialFieldName,
+		endFieldName,
+	}: RangeCurrencyUnabbreviatedStat): StatElementProps => {
+		const initialValue = get<number | undefined>(
+			offer,
+			initialFieldName,
+			undefined
+		);
+		const endValue = get<number | undefined>(offer, endFieldName, undefined);
+
+		const content = formatRange(
+			initialValue,
+			endValue,
+			"amount",
+			"unabbreviated"
+		);
+
+		return {
+			label,
+			content,
+		};
+	};

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

@@ -0,0 +1,44 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { fromRangeMonthsStat } from './rangeMonths'
+
+// describe('fromRangeMonthsStat util', () => {
+//   it.each([
+//     [{ initialTerm: 0, endTerm: 0 }, 'Term Length', 'OPEN'],
+//     [{ initialTerm: 12, endTerm: 12 }, 'Term Length', '1 year'],
+//     [{ initialTerm: 18, endTerm: 18 }, 'Term Length', '18 months'],
+//     [{ initialTerm: 1, endTerm: 12 }, 'Term Length', '1 - 12 months'],
+//     [{ initialTerm: 24, endTerm: 36 }, 'Term Length', '2 - 3 years'],
+//     [{ initialTerm: 0, endTerm: 12 }, 'Term Length', '0 - 12 months'],
+//     [{ initialTerm: 24, endTerm: 12 }, 'Term Length', 'Invalid case'],
+//   ])(
+//     'when initialFieldName is %p and endFieldName is %p, should return %s',
+//     (offer: unknown, label: string, expectedContent: string) => {
+//       const result = fromRangeMonthsStat(offer as BaseOffer)({
+//         label,
+//         initialFieldName: 'initialTerm',
+//         endFieldName: 'endTerm',
+//         format: 'rangeMonths',
+//       })
+
+//       expect(result).toEqual({ label, content: expectedContent })
+//     },
+//   )
+
+//   it.each([
+//     [{ initialTerm: undefined, endTerm: undefined }, 'Test Label', 'OPEN'],
+//     [{ initialTerm: 0, endTerm: undefined }, 'Test Label', 'OPEN'],
+//     [{ initialTerm: undefined, endTerm: 12 }, 'Test Label', 'OPEN'],
+//   ])(
+//     'should return "-" when initialFieldName or endFieldName is undefined',
+//     (offer, label, expectedContent) => {
+//       const result = fromRangeMonthsStat(offer as unknown as BaseOffer)({
+//         label,
+//         initialFieldName: 'initialTerm',
+//         endFieldName: 'endTerm',
+//         format: 'rangeMonths',
+//       })
+//       expect(result).toEqual({ label, content: expectedContent })
+//     },
+//   )
+// })

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

@@ -0,0 +1,68 @@
+import { get } from "radash";
+import type { StatElementProps } from "../types";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+
+export type RangeMonthsStat = {
+	format: "rangeMonths";
+	label: string;
+	initialFieldName: string;
+	endFieldName: string;
+};
+
+const formatTermDuration = (
+	months: number,
+	unit: "years" | "months"
+): string => {
+	if (unit === "years") {
+		return (months / 12).toString();
+	}
+	return months.toString();
+};
+
+const determineUnit = (
+	startMonths: number,
+	endMonths: number
+): "years" | "months" => {
+	const isNonZeroDivisibleBy12 = (months: number) =>
+		months > 0 && months % 12 === 0;
+	return isNonZeroDivisibleBy12(startMonths) &&
+		isNonZeroDivisibleBy12(endMonths)
+		? "years"
+		: "months";
+};
+
+export const fromRangeMonthsStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		initialFieldName,
+		endFieldName,
+	}: RangeMonthsStat): StatElementProps => {
+		const startTermDuration = get<number | undefined>(offer, initialFieldName);
+		const endTermDuration = get<number | undefined>(offer, endFieldName);
+
+		if (
+			typeof startTermDuration === "undefined" ||
+			typeof endTermDuration === "undefined" ||
+			(startTermDuration === 0 && endTermDuration === 0)
+		) {
+			return { label, content: "OPEN" };
+		}
+
+		if (startTermDuration > endTermDuration) {
+			return { label, content: "Invalid case" };
+		}
+
+		const unit = determineUnit(startTermDuration, endTermDuration);
+
+		const startFormatted = formatTermDuration(startTermDuration, unit);
+		const endFormatted = formatTermDuration(endTermDuration, unit);
+
+		if (startTermDuration === endTermDuration) {
+			const unitLabel =
+				unit === "years" && startFormatted === "1" ? "year" : unit;
+			return { label, content: `${startFormatted} ${unitLabel}` };
+		}
+
+		return { label, content: `${startFormatted} - ${endFormatted} ${unit}` };
+	};

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

@@ -0,0 +1,81 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { fromRangePercentStat } from './rangePercent'
+
+// describe('fromRangePercentStat function', () => {
+//   it.each([
+//     [{}, 'Interest Rate', 'Interest Rate', 'N/A', undefined],
+//     [
+//       { minRate: 100, maxRate: 500 },
+//       'Interest Rate',
+//       'Interest Rate',
+//       '1% - 5%',
+//       undefined,
+//     ],
+//     [{ minRate: 0, maxRate: 0 }, 'Interest Rate', 'Interest Rate', '0%', undefined],
+//     [{ minRate: 150 }, 'Interest Rate', 'Interest Rate', 'N/A', undefined],
+//     [{ maxRate: 450 }, 'Interest Rate', 'Interest Rate', 'N/A', undefined],
+//     // Test case with dynamic label value
+//     [
+//       { minRate: 100, maxRate: 500, duration: '12 months' },
+//       'Interest over ${duration}',
+//       'Interest over 12 months',
+//       '1% - 5%',
+//       'duration',
+//     ],
+//     [
+//       { minRate: 200, maxRate: 800, term: '6 months' },
+//       'Interest over ${term}',
+//       'Interest over 6 months',
+//       '2% - 8%',
+//       'term',
+//     ],
+//     // Edge case: dynamicValue is not provided in offer
+//     [
+//       { minRate: 100, maxRate: 500 },
+//       'Interest over ${duration}',
+//       'Interest over Undefined',
+//       '1% - 5%',
+//       'duration',
+//     ],
+//     // Edge case: dynamicValue is a number
+//     [
+//       { minRate: 100, maxRate: 500, months: 12 },
+//       'Interest over ${months} months',
+//       'Interest over 12 months',
+//       '1% - 5%',
+//       'months',
+//     ],
+//     // Edge case: Both initial and end values undefined
+//     [{}, 'Interest Rate', 'Interest Rate', 'N/A', undefined],
+//     // Edge case: Both initial and end values null
+//     [
+//       { minRate: null, maxRate: null },
+//       'Interest Rate',
+//       'Interest Rate',
+//       'N/A',
+//       undefined,
+//     ],
+//   ])(
+//     'should return correct label and content for offer %j',
+//     (
+//       offer: unknown,
+//       label: string,
+//       expectedLabel: string,
+//       expectedContent: string,
+//       dynamicLabelValue?: string,
+//     ) => {
+//       const result = fromRangePercentStat(offer as BaseOffer)({
+//         format: 'rangePercent',
+//         label,
+//         initialFieldName: 'minRate',
+//         endFieldName: 'maxRate',
+//         dynamicLabelValue,
+//       })
+//       expect(result).toEqual({
+//         label: expectedLabel,
+//         content: expectedContent,
+//       })
+//     },
+//   )
+// })

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

@@ -0,0 +1,38 @@
+
+import { capitalize, get } from "radash";
+import type { StatElementProps } from "../types";
+import type { BaseOffer } from "../../../types/offerCatalogSchema";
+import { formatRange } from "../../formatUtils";
+
+export type RangePercentStat = {
+	format: "rangePercent";
+	label: string;
+	initialFieldName: string;
+	endFieldName: string;
+	dynamicLabelValue?: string;
+};
+
+export const fromRangePercentStat =
+	(offer: BaseOffer) =>
+	({
+		label,
+		initialFieldName,
+		endFieldName,
+		dynamicLabelValue,
+	}: RangePercentStat): StatElementProps => {
+		const initialValue = get<number>(offer, initialFieldName);
+		const endValue = get<number>(offer, endFieldName);
+		const dynamicValue = get<number>(offer, dynamicLabelValue || "");
+
+		const content = formatRange(initialValue, endValue, "percentage");
+
+		const processedLabel = label.replace(
+			/\$\{(\w+)\}/g,
+			capitalize(`${dynamicValue}`)
+		);
+
+		return {
+			label: processedLabel,
+			content,
+		};
+	};

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

@@ -0,0 +1,26 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { recommendedCredit } from './recommendedCredit'
+
+// describe('recommendedCredit', () => {
+//   it.each([
+//     [
+//       { recommendedCreditRatings: ['limited', 'poor', 'fair', 'good', 'excellent'] },
+//       'Any',
+//     ],
+//     [{ recommendedCreditRatings: ['limited', 'poor', 'fair'] }, 'limited, poor & fair'],
+//     [{ recommendedCreditRatings: ['good', 'excellent'] }, 'good & excellent'],
+//   ])('returns %s when recommendedCreditRatings is %s', (offer, expected) => {
+//     const result = recommendedCredit(offer as unknown as BaseOffer)({
+//       format: 'recommendedCredit',
+//       label: 'Recommended Credit',
+//       fieldName: 'recommendedCreditRatings',
+//     })
+
+//     expect(result).toEqual({
+//       label: 'Recommended Credit',
+//       content: expected,
+//       isHighlighted: true,
+//     })
+//   })
+// })

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

@@ -0,0 +1,45 @@
+
+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";
+
+export type RecommendedCreditStat = {
+	format: "recommendedCredit";
+	label: string;
+	fieldName: string;
+};
+
+const RECOMMENDED_RATINGS = ["limited", "poor", "fair", "good", "excellent"];
+
+const orderRecommendedRatings = (recommendedCreditValue: string[]) => {
+	return recommendedCreditValue.sort(
+		(a, b) => RECOMMENDED_RATINGS.indexOf(a) - RECOMMENDED_RATINGS.indexOf(b)
+	);
+};
+
+const hasAllRecommendedRatings = (recommendedCreditValue: string[]) =>
+	RECOMMENDED_RATINGS.every((rating) =>
+		recommendedCreditValue.includes(rating)
+	);
+
+export const recommendedCredit =
+	(offer: BaseOffer) =>
+	({ 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");
+
+		return {
+			label,
+			content,
+			isHighlighted: true,
+		};
+	};

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

@@ -0,0 +1,28 @@
+// import type { BaseOffer } from '@capabilities/offer-catalog'
+// import { describe, expect, it } from 'vitest'
+// import { rewardsDisplay } from './rewardsDisplay'
+
+// describe('rewardsDisplay', () => {
+//   it.each([
+//     [
+//       { rewardsDescription: 'Cash Back & Travel Rewards' },
+//       'Cash Back & Travel Rewards',
+//       false,
+//     ],
+//     [{ rewardsDescription: 'Cash Back' }, 'Cash Back', false],
+//     [{ rewardsDescription: 'Travel Rewards' }, 'Travel Rewards', false],
+//     [{ rewardsDescription: null }, 'None', true],
+//   ])('returns %s when rewards is %s', (offer, expected, isNull) => {
+//     const result = rewardsDisplay(offer as unknown as BaseOffer)({
+//       format: 'rewardsDisplay',
+//       label: 'Bonus',
+//       fieldName: 'rewardsDescription',
+//     })
+
+//     expect(result).toEqual({
+//       label: 'Bonus',
+//       content: expected,
+//       isNull,
+//     })
+//   })
+// })