@stigg/react-sdk 4.4.0-beta.9 → 4.4.0

package/src/components/paywall/PlanPrice.tsx

@@ -1,10 +1,10 @@
+import React, { useEffect, useState } from 'react';
+import styled from '@emotion/styled/macro';
+import { BillingPeriod, PriceTierFragment } from '@stigg/js-client-sdk';
 import { PaywallPlan } from './types';
 import { PaywallLocalization } from './paywallTextOverrides';
 import { getPlanPrice } from '../utils/getPlanPrice';
 import { Typography } from '../common/Typography';
-import React, { useEffect, useState } from 'react';
-import styled from '@emotion/styled/macro';
-import { BillingPeriod, PriceTierFragment } from '@stigg/js-client-sdk';
 import { TiersSelectContainer } from '../common/TiersSelectContainer';
 
 const EMPTY_CHAR = '‎';
@@ -38,7 +38,7 @@ function PriceBillingPeriod({
   hasAnnuallyPrice,
   paywallLocale,
 }: PriceBillingPeriodProps) {
-  const hasPrice = plan.pricePoints.find(pricePoint => pricePoint.billingPeriod === billingPeriod);
+  const hasPrice = plan.pricePoints.find((pricePoint) => pricePoint.billingPeriod === billingPeriod);
 
   let content = EMPTY_CHAR;
   if (hasPrice && hasMonthlyPrice && hasAnnuallyPrice) {
@@ -79,7 +79,7 @@ export const PlanPrice = ({
   hasAnnuallyPrice: boolean;
   locale: string;
 }) => {
-  const { price, unit, tiers, tierUnits } = getPlanPrice(
+  const { price, unit, tiers } = getPlanPrice(
     plan,
     billingPeriod,
     paywallLocale,
@@ -87,18 +87,17 @@ export const PlanPrice = ({
     hasMonthlyPrice,
     selectedTierByFeature,
   );
-
   const [selectedTier, setSelectedTier] = useState<PriceTierFragment>();
 
-  useEffect(() => {
-    setSelectedTier(selectedTierByFeature[featureId!]);
-  }, [selectedTierByFeature]);
-
   // We currently only support prices with one tier - so we select the first one
-  const tieredPrice = plan.pricePoints.find(planPrice => {
+  const tieredPrice = plan.pricePoints.find((planPrice) => {
     return planPrice.billingPeriod === billingPeriod && planPrice.isTieredPrice;
   });
-  const featureId = tieredPrice ? tieredPrice!.feature!.featureId : undefined;
+  const featureId = tieredPrice ? tieredPrice.feature!.featureId : undefined;
+
+  useEffect(() => {
+    setSelectedTier(featureId ? selectedTierByFeature[featureId] : undefined);
+  }, [featureId, selectedTierByFeature]);
 
   const handleTierChange = (tier: PriceTierFragment) => {
     const updatedTierByFeature: Record<string, PriceTierFragment> = {};
@@ -121,8 +120,7 @@ export const PlanPrice = ({
             style={{ minHeight: '20px' }}
             className="stigg-starting-at-text"
             variant="body1"
-            color="secondary"
-          >
+            color="secondary">
             {showStartingAt ? paywallLocale.price.startingAtCaption : EMPTY_CHAR}
           </Typography>
         )}
@@ -145,15 +143,14 @@ export const PlanPrice = ({
           </Typography>
         )}
 
-        {withTiersRow && (
+        {withTiersRow ? (
           <TiersSelectContainer
             componentId={`${plan.id}_${featureId}_tier`}
             tiers={tiers}
-            tierUnits={tierUnits}
             selectedTier={selectedTier}
             handleTierChange={handleTierChange}
           />
-        )}
+        ) : null}
       </>
     </PlanPriceContainer>
   );

package/src/components/utils/currencyUtils.ts

@@ -6,17 +6,19 @@ export const currencyPriceFormatter = ({
   currency = Currency.Usd,
   locale,
   maximumFractionDigits = 5,
+  minimumFractionDigits = 0,
 }: {
   amount: number;
   currency?: Currency | string;
   locale?: string;
   maximumFractionDigits?: number;
+  minimumFractionDigits?: number;
 }) => {
   const currencyString = currency.toString();
   const currencySymbol = getSymbolFromCurrency(currencyString);
   let formattedPrice = new Intl.NumberFormat(locale, {
-    maximumFractionDigits: maximumFractionDigits,
-    minimumFractionDigits: 0,
+    maximumFractionDigits,
+    minimumFractionDigits,
     style: 'currency',
     currency: currencyString,
     ...(currencySymbol ? { currencyDisplay: 'code' } : {}),

package/src/components/utils/getFeatureName.ts

@@ -2,13 +2,21 @@ import { FeatureFragment } from '@stigg/api-client-js/src/generated/sdk';
 import lowercase from 'lodash/lowerCase';
 
 export function getFeatureDisplayName(feature: FeatureFragment) {
-  const displayNameLowerCase = lowercase(feature.displayName);
+  return getFeatureDisplayNameText(feature.displayName, feature.featureUnits, feature.featureUnitsPlural);
+}
+
+export function getFeatureDisplayNameText(featureDisplayName: string, featureUnits: string | undefined | null, featureUnitsPlural: string | undefined | null) {
+  if(!featureUnits && !featureUnitsPlural) {
+    return featureDisplayName;
+  }
+
+  const displayNameLowerCase = lowercase(featureDisplayName);
   if (
-    displayNameLowerCase === lowercase(feature.featureUnits || '') ||
-    displayNameLowerCase === lowercase(feature.featureUnitsPlural || '')
+    displayNameLowerCase === lowercase(featureUnits || '') ||
+    displayNameLowerCase === lowercase(featureUnitsPlural || '')
   ) {
-    return feature.displayName;
+    return featureDisplayName;
   }
 
-  return `${feature.displayName} (${feature.featureUnitsPlural})`;
+  return `${featureDisplayName} (${featureUnitsPlural})`;
 }

package/src/stories/Checkout.stories.tsx

@@ -4,6 +4,8 @@ import { ComponentMeta, ComponentStory } from '@storybook/react';
 import { Checkout } from '../components/checkout';
 import { StiggProvider } from '../components/StiggProvider';
 import { defaultArgsWithCustomer } from './baseArgs';
+import { mockCheckoutState } from './mocks/checkout/mockCheckoutState';
+import { mockPreviewSubscription } from './mocks/checkout/mockCheckoutPreview';
 
 export default {
   title: 'Stigg React SDK/Checkout',
@@ -21,6 +23,18 @@ export default {
       </StiggProvider>
     ),
   ],
+  parameters: {
+    controls: {
+      exclude: [
+        'onCheckout',
+        'onCheckoutCompleted',
+        'onChangePlan',
+        'onBillingAddressChange',
+        'onMockCheckoutState',
+        'onMockCheckoutPreview',
+      ],
+    },
+  },
 } as ComponentMeta<typeof Checkout>;
 
 const Wrapper = styled.div`
@@ -40,14 +54,34 @@ const Template: ComponentStory<any> = (args) => (
       }}
       onCheckout={async ({ checkoutParams, checkoutAction }) => {
         console.log('checkout started!', checkoutParams);
+        if (args.useMockData) {
+          console.log('returning mock checkout success response');
+          return { success: true };
+        }
+
         const { success, errorMessage } = await checkoutAction();
         return { success, errorMessage };
       }}
+      billableFeatures={[{ featureId: 'feature-seat', quantity: 30 }]}
       onChangePlan={({ currentPlan }) => {
         console.log('plan changed clicked!', { currentPlan });
       }}
-      // disableSuccessAnimation
-      // billingInformation={{ taxPercentage: 27 }}
+      onMockCheckoutState={
+        args.useMockData
+          ? (params) => {
+              console.log('mocking checkout state', params);
+              return mockCheckoutState(params);
+            }
+          : undefined
+      }
+      onMockCheckoutPreview={
+        args.useMockData
+          ? (params) => {
+              console.log('mocking checkout preview');
+              return mockPreviewSubscription(params);
+            }
+          : undefined
+      }
     />
   </Wrapper>
 );
@@ -56,8 +90,5 @@ export const DefaultCheckout = Template.bind({});
 DefaultCheckout.args = {
   ...defaultArgsWithCustomer,
   planId: 'plan-revvenu-essentials',
-  // baseUri: 'http://localhost:4000',
-  // apiKey: 'client-72b058a6-0f22-4c86-adce-bf266d12e12e:9f356ceb-c94c-42a4-9572-10b12824da81',
-  baseUri: 'https://api-staging.stigg.io',
-  apiKey: 'client-79584f52-7ef9-4c58-b9ac-5080acf492e4:71f2274c-100a-4fa4-8a43-48fa3b16c627',
+  useMockData: false,
 };

package/src/stories/CustomerPortal.stories.tsx

@@ -33,7 +33,7 @@ export default {
           }
         }
         baseUri={args.baseUri}
-        enableEdge={args.disableEdge}>
+        enableEdge={!args.disableEdge}>
         <Story />
       </StiggProvider>
     ),
@@ -70,7 +70,7 @@ const Template: ComponentStory<any> = (args) => {
             onPlanSelected={(...args) => {
               console.log('onPlanSelected', args);
             }}
-            highlightedPlanId="plan-revvenu-unity"
+            highlightedPlanId="plan-revvenu-essentials"
           />
         }
         theme={customerPortalTheme}

package/src/stories/mocks/checkout/consts.ts

@@ -0,0 +1,15 @@
+export const BASE_FEE_MONTHLY = 200;
+export const BASE_FEE_YEARLY = 175 * 12;
+export const TIERS = [100, 500, 750];
+export const TIERS_PRICE_MONTHLY = [10, 49, 70];
+export const TIERS_PRICE_YEARLY = [8, 35, 50].map((p) => p * 12);
+
+export const PER_UNIT_PRICE_MONTHLY = 12;
+export const PER_UNIT_PRICE_YEARLY = 10 * 12;
+
+export const ADDON_PRICE_MONTHLY = 50;
+export const ADDON_PRICE_YEARLY = 35 * 12;
+
+export const STRIPE_MOCK_ACCOUNT_ID = 'acct_1NnHoQG6EyqgvTaj';
+export const STRIPE_MOCK_ACCOUNT_PK =
+  'pk_test_51NnHoQG6EyqgvTajznajopWC01AozNtq7zgySeQ1qx4PH9TAXvMj0TnbZvYT3yOt46jbQAcCDs1EU2QKcfG8eEoO00tlW0Jp3r';

package/src/stories/mocks/checkout/mockCheckoutPreview.ts

@@ -0,0 +1,138 @@
+import moment from 'moment';
+import {
+  BillingPeriod,
+  BillingModel,
+  Currency,
+  BillableFeature,
+  DateRange,
+  Money,
+  Plan,
+  PreviewSubscription,
+  SubscriptionEstimationAddon,
+  SubscriptionPreviewV2,
+} from '@stigg/js-client-sdk';
+import { mockCheckoutState } from './mockCheckoutState';
+
+const mockBillingPeriod = (period?: BillingPeriod): DateRange => {
+  return {
+    start: moment().toDate(),
+    end: moment()
+      .add(1, period === BillingPeriod.Monthly ? 'month' : 'year')
+      .toDate(),
+  };
+};
+
+const defaultPreviewSubscription = (): SubscriptionPreviewV2 => {
+  const defaultCost: Money = {
+    amount: 0,
+    currency: Currency.Usd,
+  };
+
+  return {
+    subTotal: defaultCost,
+    total: defaultCost,
+    totalExcludingTax: defaultCost,
+    billingPeriodRange: mockBillingPeriod(),
+  };
+};
+
+const flatFeeCost = (plan: Plan, billingPeriod: BillingPeriod | undefined) => {
+  const filteredPrice = plan.pricePoints?.find(
+    (price) => price.billingPeriod === billingPeriod && price.pricingModel === BillingModel.FlatFee,
+  );
+
+  return filteredPrice?.amount || 0;
+};
+
+const addonCost = (plan: Plan, billingPeriod: BillingPeriod, addonId: string, quantity: number) => {
+  const addon = plan.compatibleAddons?.find((addon) => addon.id === addonId);
+
+  const price = addon?.pricePoints.find((price) => price.billingPeriod === billingPeriod);
+
+  return (price?.amount || 0) * quantity;
+};
+
+const billableFeatureCost = (plan: Plan, billingPeriod: BillingPeriod, featureId: string, quantity: number) => {
+  const price = plan.pricePoints.find(
+    (price) => price.feature?.featureId === featureId && price.billingPeriod === billingPeriod,
+  );
+
+  if (!price) return 0;
+
+  const { tiers } = price;
+
+  if (tiers) {
+    const quantityTier = tiers.find((tier) => tier.upTo >= quantity);
+    const priceTier = quantityTier || tiers[tiers.length - 1];
+    return quantity * priceTier.unitPrice.amount;
+  }
+
+  return (price?.amount || 0) * quantity;
+};
+
+const mockTotalPrice = (
+  plan: Plan,
+  billingPeriod: BillingPeriod,
+  addons: SubscriptionEstimationAddon[],
+  features: BillableFeature[],
+) => {
+  const currency = plan.pricePoints?.[0].currency || Currency.Usd;
+
+  const totalFlatFeeCost = flatFeeCost(plan, billingPeriod);
+  const totalFeaturesCost = features.reduce(
+    (total, feature) => total + billableFeatureCost(plan, billingPeriod, feature.featureId, feature.quantity || 0),
+    0,
+  );
+  const totalAddonsCost = addons.reduce(
+    (total, addon) => total + addonCost(plan, billingPeriod, addon.addonId, addon.quantity || 0),
+    0,
+  );
+
+  const cost: Money = {
+    amount: totalFlatFeeCost + totalFeaturesCost + totalAddonsCost,
+    currency: currency || Currency.Usd,
+  };
+
+  return {
+    subTotal: cost,
+    total: cost,
+    totalExcludingTax: cost,
+  };
+};
+
+export function mockPreviewSubscription(input: PreviewSubscription): SubscriptionPreviewV2 {
+  const {
+    planId,
+    billingPeriod = BillingPeriod.Monthly,
+    billableFeatures: features = [],
+    addons = [],
+    promotionCode,
+  } = input;
+
+  if (promotionCode) {
+    throw new Error('Error: Invalid promotion code');
+  }
+
+  const data = mockCheckoutState({ planId });
+
+  if (!data || !data.plan) {
+    return defaultPreviewSubscription();
+  }
+
+  const total = mockTotalPrice(data.plan, billingPeriod, addons, features);
+
+  if (!total) {
+    return defaultPreviewSubscription();
+  }
+
+  return {
+    ...total,
+    billingPeriodRange: mockBillingPeriod(billingPeriod),
+    proration: {
+      prorationDate: moment().toDate(),
+      credit: total.total,
+      debit: total.total,
+      netAmount: total.total,
+    },
+  };
+}

package/src/stories/mocks/checkout/mockCheckoutState.ts

@@ -0,0 +1,206 @@
+import moment from 'moment';
+import { camelCase, startCase } from 'lodash';
+import {
+  BillingModel,
+  BillingPeriod,
+  BillingVendorIdentifier,
+  Currency,
+  PricingType,
+  TiersMode,
+  CheckoutStatePlan,
+  Customer,
+  GetCheckoutState,
+  GetCheckoutStateResults,
+  Price,
+  Product,
+  PromotionalEntitlement,
+  Subscription,
+  Addon,
+} from '../../../../../js-client-sdk';
+import {
+  BASE_FEE_MONTHLY,
+  TIERS_PRICE_MONTHLY,
+  PER_UNIT_PRICE_MONTHLY,
+  PER_UNIT_PRICE_YEARLY,
+  STRIPE_MOCK_ACCOUNT_ID,
+  STRIPE_MOCK_ACCOUNT_PK,
+  TIERS,
+  BASE_FEE_YEARLY,
+  TIERS_PRICE_YEARLY,
+  ADDON_PRICE_MONTHLY,
+  ADDON_PRICE_YEARLY,
+} from './consts';
+
+const mockCustomer: Customer = {
+  id: '462d5d8a-22c4-4f22-9306-38d1a3047675',
+  name: 'John Doe',
+  email: 'john.doe@example.com',
+  createdAt: moment().subtract(1, 'year').toDate(),
+  updatedAt: moment().subtract(1, 'month').toDate(),
+  hasPaymentMethod: false,
+  promotionalEntitlements: [],
+  subscriptions: [],
+  getActivePromotionalEntitlements(): PromotionalEntitlement[] {
+    return [];
+  },
+  getActiveSubscriptions(): Subscription[] {
+    return [];
+  },
+  getActiveTrials(): Subscription[] {
+    return [];
+  },
+};
+
+const mockProduct: Product = {
+  id: 'product-1',
+  displayName: 'Product 1',
+  description: 'Product 1 description',
+};
+
+const additionalStorageAddons: Addon = {
+  id: 'addon-additional-storage',
+  description: 'Additional storage',
+  displayName: 'Additional storage',
+  entitlements: [],
+  pricePoints: [
+    {
+      pricingModel: BillingModel.FlatFee,
+      billingPeriod: BillingPeriod.Monthly,
+      amount: ADDON_PRICE_MONTHLY,
+      currency: Currency.Usd,
+      tiersMode: undefined,
+      isTieredPrice: false,
+    },
+    {
+      pricingModel: BillingModel.FlatFee,
+      billingPeriod: BillingPeriod.Annually,
+      amount: ADDON_PRICE_YEARLY,
+      currency: Currency.Usd,
+      tiersMode: undefined,
+      isTieredPrice: false,
+    },
+  ],
+};
+
+const flatFeePricing: Price[] = [
+  {
+    pricingModel: BillingModel.FlatFee,
+    billingPeriod: BillingPeriod.Monthly,
+    amount: BASE_FEE_MONTHLY,
+    currency: Currency.Usd,
+    tiersMode: undefined,
+    isTieredPrice: false,
+  },
+  {
+    pricingModel: BillingModel.FlatFee,
+    billingPeriod: BillingPeriod.Annually,
+    amount: BASE_FEE_YEARLY,
+    currency: Currency.Usd,
+    tiersMode: undefined,
+    isTieredPrice: false,
+  },
+];
+
+function tieredPricing(): Price[] {
+  const feature = {
+    featureId: 'feature-campaigns',
+    displayName: 'Campaigns per month',
+    units: 'campaign',
+    unitsPlural: 'campaigns',
+  };
+
+  return [
+    {
+      pricingModel: BillingModel.PerUnit,
+      billingPeriod: BillingPeriod.Monthly,
+      tiersMode: TiersMode.Volume,
+      tiers: TIERS.map((tier, index) => ({
+        upTo: tier,
+        unitPrice: {
+          amount: TIERS_PRICE_MONTHLY[index] / tier,
+          currency: Currency.Usd,
+        },
+      })),
+      feature,
+      currency: Currency.Usd,
+      isTieredPrice: true,
+    },
+    {
+      pricingModel: BillingModel.PerUnit,
+      billingPeriod: BillingPeriod.Annually,
+      tiersMode: TiersMode.Volume,
+      tiers: TIERS.map((tier, index) => ({
+        upTo: tier,
+        unitPrice: {
+          amount: TIERS_PRICE_YEARLY[index] / tier,
+          currency: Currency.Usd,
+        },
+      })),
+      feature,
+      currency: Currency.Usd,
+      isTieredPrice: true,
+    },
+  ];
+}
+
+function perUnitPricing(): Price[] {
+  const feature = {
+    featureId: 'feature-seats',
+    displayName: 'Seats',
+    units: 'seat',
+    unitsPlural: 'seats',
+  };
+
+  return [
+    {
+      pricingModel: BillingModel.PerUnit,
+      billingPeriod: BillingPeriod.Monthly,
+      amount: PER_UNIT_PRICE_MONTHLY,
+      currency: Currency.Usd,
+      feature,
+      tiersMode: undefined,
+      isTieredPrice: false,
+    },
+    {
+      pricingModel: BillingModel.PerUnit,
+      billingPeriod: BillingPeriod.Annually,
+      amount: PER_UNIT_PRICE_YEARLY,
+      currency: Currency.Usd,
+      feature,
+      tiersMode: undefined,
+      isTieredPrice: false,
+    },
+  ];
+}
+
+function mockPlan(planRefId: string): CheckoutStatePlan {
+  return {
+    id: '4b6c639e-1100-4ae1-86a9-31324994f992',
+    displayName: startCase(camelCase(planRefId)),
+    pricingType: PricingType.Paid,
+    pricePoints: [...flatFeePricing, ...perUnitPricing(), ...tieredPricing()],
+    product: mockProduct,
+    order: 0,
+    compatibleAddons: [additionalStorageAddons],
+    entitlements: [],
+    inheritedEntitlements: [],
+  };
+}
+
+export function mockCheckoutState(params: GetCheckoutState): GetCheckoutStateResults {
+  const { planId } = params;
+
+  return {
+    setupSecret: '',
+    customer: mockCustomer,
+    plan: mockPlan(planId),
+    billingIntegration: {
+      billingIdentifier: BillingVendorIdentifier.Stripe,
+      credentials: {
+        accountId: STRIPE_MOCK_ACCOUNT_ID,
+        publicKey: STRIPE_MOCK_ACCOUNT_PK,
+      },
+    },
+    resource: null,
+  };
+}

package/src/theme/Theme.tsx

@@ -61,13 +61,22 @@ function createTypographyTheme(theme: StiggTheme): Partial<TypographyProps> {
   };
 }
 
+const createMuiPalette = (theme: StiggTheme) => {
+  return {
+    primary: {
+      main: theme.palette.primary,
+    },
+  };
+};
+
 export const SdkThemeProvider: React.FC<PropsWithChildren<SdkThemeProviderProps>> = ({ children, componentTheme }) => {
   const theme = useStiggTheme(componentTheme);
+  const muiPalette = createMuiPalette(theme);
 
   return (
     // We are using styled-components theme here only because we are using styled-typography
     // which depends on styled-components for the typography theming
-    <MuiThemeProvider theme={createTheme({ stigg: theme })}>
+    <MuiThemeProvider theme={createTheme({ palette: muiPalette, stigg: theme })}>
       <ThemeProvider theme={{ stigg: theme }}>
         <CustomCssGlobal customCss={theme.customCss}>
           <Fonts externalFontUrl={theme.typography.fontFamilyUrl} />

package/src/theme/getResolvedTheme.ts

@@ -21,6 +21,7 @@ export const getResolvedTheme = (customizedTheme?: CustomizedTheme): StiggTheme
     palette: {
       primary: primaryColor.hex(),
       primaryDark: primaryColor.darken(0.3).hex(),
+      primaryLight: primaryColor.lighten(0.6).hex(),
       backgroundPaper: '#FFFFFF',
       backgroundHighlight: '#F5F6F9',
       backgroundSection: primaryColor.alpha(0.1).toString(),

package/src/theme/types.ts

@@ -9,6 +9,7 @@ export type StiggTheme = {
   palette: {
     primary: string;
     primaryDark: string;
+    primaryLight: string;
     backgroundPaper: string;
     backgroundHighlight: string;
     backgroundSection: string;