@automattic/data-stores 3.0.1 → 3.1.0-rc.2

package/src/plans/hooks/use-intro-offers-for-woo-express.ts

@@ -0,0 +1,49 @@
+import { isWooExpressPlan } from '@automattic/calypso-products';
+import { useMemo } from '@wordpress/element';
+import useIntroOffers from './use-intro-offers';
+import type { PlanIntroductoryOffer } from '../types';
+
+interface IntroOffersIndex {
+	[ planSlug: string ]: PlanIntroductoryOffer | null;
+}
+
+interface Props {
+	siteId: string | number | null | undefined;
+	coupon: string | undefined;
+}
+
+/**
+ * Get introductory offers for Woo Express plans that have these defined
+ * - Currently retrieved off site-plans: https://public-api.wordpress.com/rest/v1.3/sites/[siteId]/plans
+ * - Can be extended to include /plans endpoint
+ * @returns {IntroOffersIndex | undefined | null} -
+ *     an object of planSlug->PlanIntroductoryOffer if WooExpress plan offers are found, or
+ *     undefined if we haven't observed any metadata yet, or
+ *     null if there are no WooExpress intro offers
+ */
+const useIntroOffersForWooExpress = ( {
+	siteId,
+	coupon,
+}: Props ): IntroOffersIndex | undefined | null => {
+	const introOffers = useIntroOffers( { siteId, coupon } );
+
+	return useMemo( () => {
+		if ( ! introOffers ) {
+			return introOffers;
+		}
+
+		const wooExpressIntroOffers = Object.keys( introOffers )
+			.filter( isWooExpressPlan )
+			.reduce< IntroOffersIndex >(
+				( acc, planSlug ) => ( {
+					...acc,
+					...( introOffers[ planSlug ] && { [ planSlug ]: introOffers[ planSlug ] } ),
+				} ),
+				{}
+			);
+
+		return Object.keys( wooExpressIntroOffers ).length ? wooExpressIntroOffers : null;
+	}, [ introOffers ] );
+};
+
+export default useIntroOffersForWooExpress;

package/src/plans/hooks/use-intro-offers.ts

@@ -0,0 +1,45 @@
+import { useMemo } from '@wordpress/element';
+import usePlans from '../queries/use-plans';
+import useSitePlans from '../queries/use-site-plans';
+import type { PlanIntroductoryOffer } from '../types';
+
+interface IntroOffersIndex {
+	[ planSlug: string ]: PlanIntroductoryOffer | null;
+}
+
+interface Props {
+	siteId: string | number | null | undefined;
+	coupon: string | undefined;
+}
+
+/**
+ * Get introductory offers for plans that have these defined
+ * - Returns a union of the introductory offers from `/plans` and `/sites/[id]/plans` endpoints
+ * - `/sites/[id]/plans` takes precedence over `/plans` (if both are defined for a plan)
+ * @returns {IntroOffersIndex | undefined} - an object `{ [ planSlug: string ]: PlanIntroductoryOffer | null }`,
+ * or `undefined` if we haven't observed any metadata yet
+ */
+const useIntroOffers = ( { siteId, coupon }: Props ): IntroOffersIndex | undefined => {
+	const sitePlans = useSitePlans( { siteId } );
+	const plans = usePlans( { coupon } );
+
+	return useMemo( () => {
+		if ( ! sitePlans.data && ! plans.data ) {
+			return undefined;
+		}
+
+		return Object.keys( { ...sitePlans.data, ...plans.data } ).reduce< IntroOffersIndex >(
+			( acc, planSlug ) => {
+				const plan = sitePlans?.data?.[ planSlug ] ?? plans?.data?.[ planSlug ];
+
+				return {
+					...acc,
+					[ planSlug ]: plan?.pricing?.introOffer ?? null,
+				};
+			},
+			{}
+		);
+	}, [ sitePlans.data, plans.data ] );
+};
+
+export default useIntroOffers;

package/src/plans/hooks/use-pricing-meta-for-grid-plans.ts

@@ -0,0 +1,325 @@
+import {
+	PLAN_MONTHLY_PERIOD,
+	type PlanSlug,
+	getTermFromDuration,
+	calculateMonthlyPrice,
+} from '@automattic/calypso-products';
+import { useSelect } from '@wordpress/data';
+import * as Plans from '../';
+import * as Purchases from '../../purchases';
+import * as WpcomPlansUI from '../../wpcom-plans-ui';
+import { COST_OVERRIDE_REASONS } from '../constants';
+import type { AddOnMeta } from '../../add-ons/types';
+
+export type UseCheckPlanAvailabilityForPurchase = ( {
+	planSlugs,
+	siteId,
+	shouldIgnorePlanOwnership,
+}: {
+	planSlugs: PlanSlug[];
+	siteId?: number | null;
+	shouldIgnorePlanOwnership?: boolean;
+} ) => {
+	[ planSlug in PlanSlug ]?: boolean;
+};
+
+interface Props {
+	planSlugs: PlanSlug[];
+
+	/**
+	 * `siteId` required on purpose to mitigate risk with not passing something through when we should
+	 */
+	siteId: number | null | undefined;
+
+	/**
+	 * `coupon` required on purpose to mitigate risk with not passing somethiing through when we should
+	 */
+	coupon: string | undefined;
+
+	/**
+	 * `useCheckPlanAvailabilityForPurchase` required on purpose to avoid inconsistent data across Calypso.
+	 *     - It returns an index of planSlugs and whether they are available for purchase (non-available plans
+	 * will not have the discounted prices attached).
+	 *     - It's a function that is not available in the data store, but can be easily mocked in other contexts.
+	 *     - For Calypso instances, this should be the same function. So find other/existing cases and import the same.
+	 */
+	useCheckPlanAvailabilityForPurchase: UseCheckPlanAvailabilityForPurchase;
+
+	/**
+	 * `storageAddOmns` TODO: should become a required prop.
+	 */
+	storageAddOns: ( AddOnMeta | null )[] | null;
+
+	/**
+	 * Whether to include discounts from plan proration.
+	 * This is applicable only if a siteId is passed to this hook.
+	 * If true, the pricing includes discounts from upgrade credits.
+	 */
+	withProratedDiscounts?: boolean;
+}
+
+function getTotalPrice( planPrice: number | null | undefined, addOnPrice = 0 ): number | null {
+	return null !== planPrice && undefined !== planPrice ? planPrice + addOnPrice : null;
+}
+
+/**
+ * This hook is a re-projection of the the pricing metadata derived from `usePlans` and `useSitePlans` hooks.
+ * It returns the pricing metadata as needed for the Calypso grid components, which may be adjusted based on the selected site,
+ * storage add-ons, current plan (will use the actual purchase price for `originalPrice` in this case), etc.
+ *
+ * For most uses within Calypso (e.g. pricing grids), this should work. However, if you need to access the pricing metadata directly,
+ * you should use the `usePlans` and `useSitePlans` hooks instead.
+ *
+ * Check the properties, incode docs (numbered set of cases), and `PricingMetaForGridPlan` type for additional details.
+ */
+const usePricingMetaForGridPlans = ( {
+	planSlugs,
+	siteId,
+	coupon,
+	useCheckPlanAvailabilityForPurchase,
+	storageAddOns,
+	withProratedDiscounts,
+}: Props ): { [ planSlug: string ]: Plans.PricingMetaForGridPlan } | null => {
+	// plans - should have a definition for all plans, being the main source of API data
+	const plans = Plans.usePlans( { coupon } );
+	// sitePlans - unclear if all plans are included
+	const sitePlans = Plans.useSitePlans( { siteId } );
+	const currentPlan = Plans.useCurrentPlan( { siteId } );
+	const introOffers = Plans.useIntroOffers( { siteId, coupon } );
+	const purchasedPlan = Purchases.useSitePurchaseById( {
+		siteId,
+		purchaseId: currentPlan?.purchaseId,
+	} );
+	const selectedStorageOptions = useSelect(
+		( select ) => select( WpcomPlansUI.store ).getSelectedStorageOptions( siteId ),
+		[]
+	);
+	const planAvailabilityForPurchase = useCheckPlanAvailabilityForPurchase( {
+		planSlugs,
+		siteId,
+
+		// TODO:
+		// We need to ignore plan ownership only if the site is on a paid plan so the CTAs are enabled for non-owner actions.
+		// See https://github.com/Automattic/wp-calypso/issues/87479 for more details.
+		// However, it's technically "not available for purchase for the current user", so it'd be better if the state
+		// can express it more explicitly.
+		shouldIgnorePlanOwnership: !! currentPlan?.purchaseId,
+	} );
+
+	let planPrices:
+		| {
+				[ planSlug in PlanSlug ]?: {
+					originalPrice: Plans.PlanPricing[ 'originalPrice' ];
+					discountedPrice: Plans.PlanPricing[ 'discountedPrice' ];
+					currencyCode: Plans.PlanPricing[ 'currencyCode' ];
+				};
+		  }
+		| null = null;
+
+	if ( ( siteId && sitePlans.isLoading ) || plans.isLoading ) {
+		/**
+		 * Null until all data is ready, at least in initial state.
+		 * - For now a simple loader is shown until these are resolved
+		 * - `sitePlans` being a dependent query will only get fetching status when enabled (when `selectedSiteId` exists)
+		 */
+		planPrices = null;
+	} else {
+		planPrices = Object.fromEntries(
+			planSlugs.map( ( planSlug ) => {
+				const plan = plans.data?.[ planSlug ];
+				const sitePlan = sitePlans.data?.[ planSlug ];
+				const selectedStorageOption = selectedStorageOptions?.[ planSlug ];
+				const selectedStorageAddOn = selectedStorageOption
+					? storageAddOns?.find( ( addOn ) => {
+							return addOn?.addOnSlug === selectedStorageOption;
+					  } )
+					: null;
+				const storageAddOnPriceMonthly = selectedStorageAddOn?.prices?.monthlyPrice || 0;
+				const storageAddOnPriceYearly = selectedStorageAddOn?.prices?.yearlyPrice || 0;
+
+				/**
+				 * 0. No plan or sitePlan (when selected site exists): planSlug is for a priceless plan.
+				 * TODO clk: the condition on `.pricing` here needs investigation. There should be a pricing object for all returned API plans.
+				 */
+				if ( ! plan?.pricing || ( siteId && ! sitePlan?.pricing ) ) {
+					return [
+						planSlug,
+						{
+							originalPrice: {
+								monthly: null,
+								full: null,
+							},
+							discountedPrice: {
+								monthly: null,
+								full: null,
+							},
+							currencyCode: plans.data?.[ planSlug ]?.pricing?.currencyCode,
+						},
+					];
+				}
+
+				/**
+				 * 1. Original prices only for current site's plan.
+				 *   - The current site's plan gets the price with which the plan was purchased
+				 *     (so may not be the most recent billing plan's).
+				 */
+				if ( siteId && currentPlan?.planSlug === planSlug ) {
+					let monthlyPrice = sitePlan?.pricing.originalPrice.monthly;
+					let fullPrice = sitePlan?.pricing.originalPrice.full;
+
+					/**
+					 * Ensure the spotlight (current) plan shows the price with which the plan was purchased.
+					 */
+					if ( purchasedPlan ) {
+						const isMonthly = purchasedPlan.billPeriodDays === PLAN_MONTHLY_PERIOD;
+
+						if ( isMonthly && monthlyPrice !== purchasedPlan.priceInteger ) {
+							monthlyPrice = purchasedPlan.priceInteger;
+							fullPrice = parseFloat( ( purchasedPlan.priceInteger * 12 ).toFixed( 2 ) );
+						} else if ( fullPrice !== purchasedPlan.priceInteger ) {
+							const term = getTermFromDuration( purchasedPlan.billPeriodDays ) || '';
+							monthlyPrice = calculateMonthlyPrice( term, purchasedPlan.priceInteger );
+							fullPrice = purchasedPlan.priceInteger;
+						}
+					}
+
+					return [
+						planSlug,
+						{
+							originalPrice: {
+								monthly: getTotalPrice( monthlyPrice ?? null, storageAddOnPriceMonthly ),
+								full: getTotalPrice( fullPrice ?? null, storageAddOnPriceYearly ),
+							},
+							discountedPrice: {
+								monthly: null,
+								full: null,
+							},
+							currencyCode: purchasedPlan
+								? purchasedPlan?.currencyCode
+								: plan?.pricing?.currencyCode,
+						},
+					];
+				}
+
+				/**
+				 * 2. Original and Discounted prices for site-specific plans available for purchase
+				 */
+				if ( siteId && planAvailabilityForPurchase[ planSlug ] ) {
+					const originalPrice = {
+						monthly: getTotalPrice(
+							sitePlan?.pricing.originalPrice.monthly,
+							storageAddOnPriceMonthly
+						),
+						full: getTotalPrice( sitePlan?.pricing.originalPrice.full, storageAddOnPriceYearly ),
+					};
+
+					// Do not return discounted prices if discount is due to plan proration
+					if (
+						! withProratedDiscounts &&
+						sitePlan?.pricing?.costOverrides?.[ 0 ]?.overrideCode ===
+							COST_OVERRIDE_REASONS.RECENT_PLAN_PRORATION
+					) {
+						return [
+							planSlug,
+							{
+								originalPrice,
+								discountedPrice: {
+									monthly: null,
+									full: null,
+								},
+								currencyCode: sitePlan?.pricing?.currencyCode,
+							},
+						];
+					}
+
+					const discountedPrice = {
+						monthly: getTotalPrice(
+							sitePlan?.pricing.discountedPrice.monthly,
+							storageAddOnPriceMonthly
+						),
+						full: getTotalPrice( sitePlan?.pricing.discountedPrice.full, storageAddOnPriceYearly ),
+					};
+
+					return [
+						planSlug,
+						{
+							originalPrice,
+							discountedPrice,
+							currencyCode: sitePlan?.pricing?.currencyCode,
+						},
+					];
+				}
+
+				/**
+				 * 3. Original and Discounted prices for plan available for purchase.
+				 */
+				if ( planAvailabilityForPurchase[ planSlug ] ) {
+					const originalPrice = {
+						monthly: getTotalPrice( plan.pricing.originalPrice.monthly, storageAddOnPriceMonthly ),
+						full: getTotalPrice( plan.pricing.originalPrice.full, storageAddOnPriceYearly ),
+					};
+					const discountedPrice = {
+						monthly: getTotalPrice(
+							plan.pricing.discountedPrice.monthly,
+							storageAddOnPriceMonthly
+						),
+						full: getTotalPrice( plan.pricing.discountedPrice.full, storageAddOnPriceYearly ),
+					};
+
+					return [
+						planSlug,
+						{
+							originalPrice,
+							discountedPrice,
+							currencyCode: plan?.pricing?.currencyCode,
+						},
+					];
+				}
+
+				/**
+				 * 3. Original prices only for plan not available for purchase.
+				 */
+				return [
+					planSlug,
+					{
+						originalPrice: {
+							monthly: getTotalPrice(
+								plan.pricing.originalPrice.monthly,
+								storageAddOnPriceMonthly
+							),
+							full: getTotalPrice( plan.pricing.originalPrice.full, storageAddOnPriceYearly ),
+						},
+						discountedPrice: {
+							monthly: null,
+							full: null,
+						},
+						currencyCode: plan?.pricing?.currencyCode,
+					},
+				];
+			} )
+		);
+	}
+
+	return (
+		// TODO: consider removing the null return
+		planPrices &&
+		planSlugs.reduce(
+			( acc, planSlug ) => ( {
+				...acc,
+				[ planSlug ]: {
+					originalPrice: planPrices?.[ planSlug ]?.originalPrice,
+					discountedPrice: planPrices?.[ planSlug ]?.discountedPrice,
+					// TODO clk: the condition on `.pricing` here needs investigation. There should be a pricing object for all returned API plans.
+					billingPeriod: plans.data?.[ planSlug ]?.pricing?.billPeriod,
+					// TODO clk: the condition on `.pricing` here needs investigation. There should be a pricing object for all returned API plans.
+					currencyCode: planPrices?.[ planSlug ]?.currencyCode,
+					expiry: sitePlans.data?.[ planSlug ]?.expiry,
+					introOffer: introOffers?.[ planSlug ],
+				},
+			} ),
+			{} as { [ planSlug in PlanSlug ]?: Plans.PricingMetaForGridPlan }
+		)
+	);
+};
+
+export default usePricingMetaForGridPlans;

package/src/plans/index.ts

@@ -5,11 +5,12 @@ import { STORE_KEY } from './constants';
 import reducer, { State } from './reducer';
 import * as resolvers from './resolvers';
 import * as selectors from './selectors';
-import type { SelectFromMap, DispatchFromMap } from '../mapped-types';
 
+/** Types */
 export type { State };
 export type {
 	Plan,
+	SitePlan,
 	PlanSlug,
 	StorePlanSlug,
 	PlanProduct,
@@ -17,7 +18,21 @@ export type {
 	PlanPath,
 	PlanBillingPeriod,
 	PlanSimplifiedFeature,
+	PlanPricing,
+	PricingMetaForGridPlan,
 } from './types';
+export type { UseCheckPlanAvailabilityForPurchase } from './hooks/use-pricing-meta-for-grid-plans';
+
+/** Queries */
+export { default as usePlans } from './queries/use-plans';
+export { default as useSitePlans } from './queries/use-site-plans';
+/** Hooks/Selectors */
+export { default as useCurrentPlan } from './hooks/use-current-plan';
+export { default as useCurrentPlanTerm } from './hooks/use-current-plan-term';
+export { default as useIntroOffers } from './hooks/use-intro-offers';
+export { default as useIntroOffersForWooExpress } from './hooks/use-intro-offers-for-woo-express';
+export { default as usePricingMetaForGridPlans } from './hooks/use-pricing-meta-for-grid-plans';
+export { default as useCurrentPlanExpiryDate } from './hooks/use-current-plan-expiry-date';
 
 // plansSlugs is a list with the identifiers for each plan and they are agnostic of billing period; eg: 'free', 'personal'
 // plansSlugs is also used to construct the route that accepts plan slugs like '/free', '/personal', '/business'
@@ -39,18 +54,13 @@ let isRegistered = false;
 export function register(): typeof STORE_KEY {
 	if ( ! isRegistered ) {
 		isRegistered = true;
-		registerStore< State >( STORE_KEY, {
+		registerStore( STORE_KEY, {
 			resolvers,
 			actions,
-			controls: controls as any,
+			controls,
 			reducer,
 			selectors,
 		} );
 	}
 	return STORE_KEY;
 }
-
-declare module '@wordpress/data' {
-	function dispatch( key: typeof STORE_KEY ): DispatchFromMap< typeof actions >;
-	function select( key: typeof STORE_KEY ): SelectFromMap< typeof selectors >;
-}

package/src/plans/mock/apis/plans.ts

@@ -132,7 +132,10 @@ export const API_PLAN_PRICE_FREE: MockPricedAPIPlanFree = {
 	bill_period_label: 'for life',
 	price: '€0',
 	formatted_price: '€0',
+	product_display_price: '<abbr title="Euros">€</abbr>0',
+	orig_cost_integer: 0,
 	raw_price: 0,
+	raw_price_integer: 0,
 	tagline: 'Perfect for anyone creating a basic blog or site',
 	currency_code: 'EUR',
 	features_highlight: [
@@ -170,7 +173,10 @@ export const API_PLAN_PRICE_PREMIUM_ANNUALLY: MockPricedAPIPlanPaidAnnually = {
 	bill_period_label: 'per year',
 	price: '€96',
 	formatted_price: '€96',
+	product_display_price: '<abbr title="Euros">€</abbr>96',
+	orig_cost_integer: 9600,
 	raw_price: 96,
+	raw_price_integer: 9600,
 	tagline: 'Perfect for bloggers, creatives, and other professionals',
 	currency_code: 'EUR',
 	features_highlight: [
@@ -213,7 +219,10 @@ export const API_PLAN_PRICE_PREMIUM_MONTHLY: MockPricedAPIPlanPaidMonthly = {
 	bill_period_label: 'per month',
 	price: '€14',
 	formatted_price: '€14',
+	product_display_price: '<abbr title="Euros">€</abbr>14',
+	orig_cost_integer: 1400,
 	raw_price: 14,
+	raw_price_integer: 1400,
 	tagline: null,
 	currency_code: 'EUR',
 };

package/src/plans/mock/index.ts

@@ -3,3 +3,7 @@ export * from './apis/plans';
 export * from './store/features';
 export * from './store/plans';
 export * from './store/products';
+/**
+ * New mocks to gradually inform/replace the above.
+ */
+export * from './next';

package/src/plans/mock/next/README.md

@@ -0,0 +1,3 @@
+# Mocked data for testing
+
+Mocks under `/mock/next` will gradually evolve to inform & override the previous ones in `/mock` folder.

package/src/plans/mock/next/index.ts

@@ -0,0 +1 @@
+export * from './store/plans';

package/src/plans/mock/next/store/plans.ts

@@ -0,0 +1,102 @@
+import type { SitePlan, PlanNext } from '../../../types';
+
+/**
+ * Site Plans
+ */
+
+export const NEXT_STORE_SITE_PLAN_PERSONAL: SitePlan = {
+	planSlug: 'personal-bundle',
+	productSlug: 'personal-bundle',
+	productId: 1,
+	pricing: {
+		currencyCode: 'USD',
+		introOffer: null,
+		originalPrice: {
+			monthly: 400,
+			full: 4800,
+		},
+		discountedPrice: {
+			monthly: null,
+			full: null,
+		},
+	},
+};
+
+export const NEXT_STORE_SITE_PLAN_BUSINESS: SitePlan = {
+	planSlug: 'business-bundle',
+	productSlug: 'business-bundle',
+	productId: 2,
+	pricing: {
+		introOffer: {
+			formattedPrice: '$15.00',
+			rawPrice: 15,
+			intervalUnit: 'month',
+			intervalCount: 1,
+			isOfferComplete: false,
+		},
+		originalPrice: {
+			monthly: 2500,
+			full: 30000,
+		},
+		discountedPrice: {
+			monthly: null,
+			full: null,
+		},
+		currencyCode: 'USD',
+	},
+};
+
+export const NEXT_STORE_SITE_PLAN_BUSINESS_CURRENT: SitePlan = {
+	...NEXT_STORE_SITE_PLAN_BUSINESS,
+	currentPlan: true,
+};
+
+/**
+ * Plans
+ */
+
+export const NEXT_STORE_PLAN_PERSONAL: PlanNext = {
+	planSlug: 'personal-bundle',
+	productSlug: 'personal-bundle',
+	productId: 1,
+	productNameShort: 'Personal',
+	pricing: {
+		billPeriod: 365,
+		currencyCode: 'USD',
+		introOffer: null,
+		originalPrice: {
+			monthly: 400,
+			full: 4800,
+		},
+		discountedPrice: {
+			monthly: null,
+			full: null,
+		},
+	},
+};
+
+export const NEXT_STORE_PLAN_BUSINESS: PlanNext = {
+	planSlug: 'business-bundle',
+	productSlug: 'business-bundle',
+	productId: 2,
+	productNameShort: 'Business',
+	pricing: {
+		billPeriod: 365,
+		currencyCode: 'USD',
+		introOffer: {
+			formattedPrice: '$25.00',
+			rawPrice: 25,
+			intervalUnit: 'month',
+			intervalCount: 1,
+			isOfferComplete: false,
+		},
+		originalPrice: {
+			monthly: 2500,
+			full: 30000,
+		},
+		discountedPrice: {
+			monthly: null,
+			full: null,
+		},
+	},
+};

package/src/plans/mock/store/products.ts

@@ -20,7 +20,7 @@ export const STORE_PRODUCT_PREMIUM_ANNUALLY: PlanProduct = {
 	pathSlug: 'premium',
 	price: '€8',
 	annualPrice: '€96',
-	annualDiscount: 43,
+	annualDiscount: 42,
 };
 export const STORE_PRODUCT_PREMIUM_MONTHLY: PlanProduct = {
 	productId: 1013,
@@ -30,5 +30,5 @@ export const STORE_PRODUCT_PREMIUM_MONTHLY: PlanProduct = {
 	rawPrice: 14,
 	price: '€14',
 	annualPrice: '€168',
-	annualDiscount: 43,
+	annualDiscount: 42,
 };

package/src/plans/queries/lib/unpack-cost-overrides.ts

@@ -0,0 +1,18 @@
+import { CostOverride, PricedAPISitePlan } from '../../types';
+
+/**
+ * Unpacks cost overrides from an API plan to the respective `PlanCostOverride` structure for the store.
+ */
+export default function unpackCostOverrides( plan: PricedAPISitePlan ): CostOverride[] | undefined {
+	if ( ! plan?.cost_overrides?.length ) {
+		return undefined;
+	}
+	return plan?.cost_overrides?.map( ( costOverride ) => ( {
+		doesOverrideOriginalCost: costOverride.does_override_original_cost,
+		firstUnitOnly: costOverride.first_unit_only,
+		newPrice: costOverride.new_price,
+		oldPrice: costOverride.old_price,
+		overrideCode: costOverride.override_code,
+		percentage: costOverride.percentage,
+	} ) );
+}