@stigg/react-sdk 5.2.1 → 5.4.0

package/src/components/utils/priceTierUtils.ts

@@ -1,5 +1,6 @@
 import { BillingModel, TiersMode, BillingPeriod, Price, PriceTierFragment, Subscription } from '@stigg/js-client-sdk';
 import isNil from 'lodash/isNil';
+import { sum } from 'lodash';
 import { PaywallPlan } from '../paywall';
 import { SelectDefaultTierIndexFn } from '../paywall/types';
 
@@ -11,9 +12,7 @@ export function getPriceFeatureUnit(price: Price) {
   return (price.feature.unitQuantity !== 1 ? price.feature.unitsPlural : price.feature.units) || '';
 }
 
-export function getTierByQuantity(tiers: PriceTierFragment[], quantity: number) {
-  if (!tiers) return undefined;
-
+export function getTierByQuantity(tiers: PriceTierFragment[], quantity: number): PriceTierFragment {
   const ascendingTiers = [...tiers];
   // Sort tiers by upTo value, ascending, if upTo is not set,
   // put it at the end as it represent the last infinity tier
@@ -32,7 +31,7 @@ function getAmount(amount: number, selectedBillingPeriod?: BillingPeriod, should
   return selectedBillingPeriod === BillingPeriod.Annually && shouldShowMonthlyPriceAmount ? amount / 12 : amount;
 }
 
-export function calculateTierPriceVolume(
+function calculateTierPriceVolume(
   currentTier: PriceTierFragment,
   perUnitQuantity: number,
   selectedBillingPeriod?: BillingPeriod,
@@ -52,66 +51,84 @@ export function calculateTierPriceVolume(
   return amount;
 }
 
+export function calculateTierPriceGraduated(
+  tiers: PriceTierFragment[],
+  unitQuantity: number,
+  selectedBillingPeriod?: BillingPeriod,
+  shouldShowMonthlyPriceAmount?: boolean,
+): { total: number; breakdown: Array<{ unitQuantity: number; amount: number }> } {
+  let remainingQuantity = unitQuantity;
+  let prevUpTo = 0;
+  let currentTierIndex = 0;
+
+  const breakdown: Array<{ unitQuantity: number; amount: number }> = [];
+
+  while (remainingQuantity > 0 && currentTierIndex < tiers.length) {
+    const tier = tiers[currentTierIndex];
+    const { upTo } = tier;
+
+    if (isNil(upTo)) {
+      breakdown.push({
+        unitQuantity: remainingQuantity,
+        amount: calculateTierPriceVolume(tier, remainingQuantity, selectedBillingPeriod, shouldShowMonthlyPriceAmount),
+      });
+      remainingQuantity = 0;
+    } else {
+      const unitsInTier = upTo - prevUpTo;
+      const consumed = Math.min(remainingQuantity, unitsInTier);
+      breakdown.push({
+        unitQuantity: consumed,
+        amount: calculateTierPriceVolume(tier, consumed, selectedBillingPeriod, shouldShowMonthlyPriceAmount),
+      });
+      remainingQuantity -= consumed;
+      prevUpTo = upTo;
+    }
+
+    currentTierIndex += 1;
+  }
+
+  const total = sum(breakdown.map(({ amount }) => amount));
+
+  return {
+    breakdown,
+    total,
+  };
+}
+
 export function calculateTierPrice(
-  price: Price,
-  currentTier: PriceTierFragment,
-  selectedBillingPeriod: BillingPeriod,
-  shouldShowMonthlyPriceAmount: boolean,
-  perUnitQuantity: number,
+  price: Pick<Price, 'tiers' | 'tiersMode'>,
+  unitQuantity: number,
+  selectedBillingPeriod?: BillingPeriod,
+  shouldShowMonthlyPriceAmount?: boolean,
 ): number {
+  if (!price.tiers) {
+    return 0;
+  }
+
   switch (price.tiersMode) {
     case TiersMode.Volume: {
-      return calculateTierPriceVolume(
-        currentTier,
-        perUnitQuantity,
-        selectedBillingPeriod,
-        shouldShowMonthlyPriceAmount,
-      );
+      const currentTier = getTierByQuantity(price.tiers, unitQuantity);
+      return calculateTierPriceVolume(currentTier, unitQuantity, selectedBillingPeriod, shouldShowMonthlyPriceAmount);
+    }
+    case TiersMode.Graduated: {
+      return calculateTierPriceGraduated(price.tiers, unitQuantity, selectedBillingPeriod, shouldShowMonthlyPriceAmount)
+        .total;
     }
     default:
       return 0;
   }
 }
 
-export function getSelectedTierQuantityBeFeature(
-  plan: PaywallPlan,
-  billingPeriod: BillingPeriod,
-  currentSubscription: Subscription | null,
-) {
-  const result: Record<string, number> = {};
-  const planTierPrices = plan.pricePoints.filter(
-    (price) => price.billingPeriod === billingPeriod && price.isTieredPrice,
-  );
-  if (planTierPrices.length === 1) {
-    const [price] = planTierPrices;
-    const featureId = price?.feature!.featureId;
-    if (currentSubscription && currentSubscription.plan.id === plan.id) {
-      const tieredPrice = currentSubscription?.prices.find(
-        (subscriptionPrice) =>
-          subscriptionPrice.pricingModel === BillingModel.PerUnit &&
-          subscriptionPrice.tiersMode &&
-          subscriptionPrice.feature?.featureId === featureId,
-      );
-      if (tieredPrice) {
-        result[featureId] = tieredPrice.feature?.unitQuantity || 1;
-      }
-    }
-  }
-
-  return result;
-}
-
 export function hasTierWithUnitPrice(tiers: PriceTierFragment[] | null | undefined) {
   return tiers?.some(({ unitPrice, upTo }) => unitPrice && !isNil(upTo));
 }
 
-export function getSelectedTier(
+export function getTiersPerUnitQuantities(
   plan: PaywallPlan,
   billingPeriod: BillingPeriod,
   currentSubscription: Subscription | null,
-  selectedTierByFeature: Record<string, PriceTierFragment>,
   selectDefaultTierIndex?: SelectDefaultTierIndexFn,
-): Record<string, PriceTierFragment> {
+): Record<string, number> {
   const planTierPrices = plan.pricePoints.filter(
     (price) => price.billingPeriod === billingPeriod && price.isTieredPrice,
   );
@@ -120,11 +137,10 @@ export function getSelectedTier(
     const [price] = planTierPrices;
     const { featureId } = price.feature!;
     const selectedDefaultTierIndex = selectDefaultTierIndex ? selectDefaultTierIndex({ plan }) : 0;
-    let currentTier = price.tiers![selectedDefaultTierIndex];
+    const currentTier = price.tiers![selectedDefaultTierIndex];
+    let quantity = hasTierWithUnitPrice(price.tiers) ? 1 : currentTier.upTo || 1;
 
-    if (selectedTierByFeature[featureId]) {
-      currentTier = price.tiers?.find((tier) => tier.upTo === selectedTierByFeature[featureId].upTo) || currentTier;
-    } else if (currentSubscription && currentSubscription.plan.id === plan.id) {
+    if (currentSubscription && currentSubscription.plan.id === plan.id) {
       const tieredPrice = currentSubscription.prices.find(
         (subscriptionPrice) =>
           subscriptionPrice.pricingModel === BillingModel.PerUnit &&
@@ -133,12 +149,12 @@ export function getSelectedTier(
       );
 
       if (tieredPrice) {
-        currentTier = getTierByQuantity(price.tiers!, tieredPrice.feature!.unitQuantity || 1)!;
+        quantity = tieredPrice.feature!.unitQuantity || 1;
       }
     }
 
-    const result: Record<string, PriceTierFragment> = {};
-    result[featureId] = currentTier;
+    const result: Record<string, number> = {};
+    result[featureId] = quantity;
 
     return result;
   }
@@ -153,11 +169,10 @@ export enum PriceTierComparison {
 }
 
 export function compareSelectedTierToCurrentTier(
-  selectedTierByFeature: Record<string, PriceTierFragment>,
   perUnitQuantityByFeature: Record<string, number>,
   currentSubscription: Subscription | null,
 ): PriceTierComparison {
-  if (!currentSubscription || !selectedTierByFeature) {
+  if (!currentSubscription) {
     return PriceTierComparison.Equal;
   }
 
@@ -168,29 +183,19 @@ export function compareSelectedTierToCurrentTier(
     return PriceTierComparison.Equal;
   }
 
-  const { featureId, unitQuantity } = currentTierPrice.feature!;
-  const { tiers } = currentTierPrice;
+  const { featureId, unitQuantity: oldQuantity } = currentTierPrice.feature!;
 
-  if (!unitQuantity) {
+  if (isNil(oldQuantity)) {
     return PriceTierComparison.Equal;
   }
 
-  const selectedTier = selectedTierByFeature[featureId];
-  const selectedQuantity = perUnitQuantityByFeature[featureId];
-  if (!selectedTier) {
-    return PriceTierComparison.Equal;
-  }
+  const newQuantity = perUnitQuantityByFeature[featureId];
 
-  const effectiveQuantity = hasTierWithUnitPrice(tiers) ? selectedQuantity : selectedTier.upTo;
-
-  if (!isNil(effectiveQuantity)) {
-    if (effectiveQuantity < unitQuantity) {
-      return PriceTierComparison.Lower;
-    }
-    if (effectiveQuantity > unitQuantity) {
-      return PriceTierComparison.Higher;
-    }
+  if (newQuantity < oldQuantity) {
+    return PriceTierComparison.Lower;
+  }
+  if (newQuantity > oldQuantity) {
+    return PriceTierComparison.Higher;
   }
-
   return PriceTierComparison.Equal;
 }