payment-kit 1.13.15

package/src/libs/util.ts

@@ -0,0 +1,474 @@
+import type {
+  LineItem,
+  PriceRecurring,
+  TCheckoutSessionExpanded,
+  TLineItemExpanded,
+  TPaymentCurrency,
+  TPaymentLinkExpanded,
+  TPrice,
+  TProductExpanded,
+  TSubscriptionItemExpanded,
+} from '@did-pay/types';
+import { BN, fromUnitToToken } from '@ocap/util';
+import cloneDeep from 'lodash/cloneDeep';
+
+import dayjs from './dayjs';
+
+export function getExplorerLink(chainHost: string, did: string, type: string) {
+  if (!chainHost) return undefined;
+  try {
+    const chainUrl = new URL(chainHost);
+    switch (type) {
+      case 'asset':
+        chainUrl.pathname = `/explorer/assets/${did}`;
+        break;
+      case 'account':
+        chainUrl.pathname = `/explorer/accounts/${did}`;
+        break;
+      case 'tx':
+        chainUrl.pathname = `/explorer/txs/${did}`;
+        break;
+      case 'token':
+        chainUrl.pathname = `/explorer/tokens/${did}`;
+        break;
+      case 'factory':
+        chainUrl.pathname = `/explorer/factories/${did}`;
+        break;
+      case 'bridge':
+        chainUrl.pathname = `/explorer/bridges/${did}`;
+        break;
+      default:
+        chainUrl.pathname = '/';
+    }
+
+    return chainUrl.href;
+  } catch {
+    return undefined;
+  }
+}
+
+export function formatToDate(date: Date | string | number, locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+
+  return dayjs(date).locale(formatLocale(locale)).format('ll');
+}
+
+export function formatToDatetime(date: Date | string | number, locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+
+  return dayjs(date).locale(formatLocale(locale)).format('lll');
+}
+
+export function formatTime(date: Date | string | number, format = 'lll', locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+
+  return dayjs(date).locale(formatLocale(locale)).format(format);
+}
+
+export function formatDateTime(date: Date | string | number, locale = 'en') {
+  return dayjs(date).locale(formatLocale(locale)).format('YYYY-MM-DD HH:mm');
+}
+
+export const formatLocale = (locale = 'en') => {
+  if (locale === 'tw') {
+    return 'zh';
+  }
+
+  return locale;
+};
+
+export const formatPrettyMsLocale = (locale: string) => (locale === 'zh' ? 'zh_CN' : 'en_US');
+
+export const formatError = (err: any) => {
+  const { details, errors, response } = err;
+
+  // graphql error
+  if (Array.isArray(errors)) {
+    return errors.map((x) => x.message).join('\n');
+  }
+
+  // joi validate error
+  if (Array.isArray(details)) {
+    const formatted = details.map((e) => {
+      const errorMessage = e.message.replace(/["]/g, "'");
+      const errorPath = e.path.join('.');
+      return `${errorPath}: ${errorMessage}`;
+    });
+
+    return `Validate failed: ${formatted.join(';')}`;
+  }
+
+  // axios error
+  if (response) {
+    return response.data.error || `${err.message}: ${JSON.stringify(response.data)}`;
+  }
+
+  return err.message;
+};
+
+export const formatProductPrice = (
+  { prices, unit_label }: { prices: TPrice[]; unit_label: string },
+  currency: TPaymentCurrency
+): string => {
+  if (prices.length > 1) {
+    return `${prices.length} prices`;
+  }
+
+  if (prices.length === 1) {
+    return formatPrice(prices[0] as TPrice, currency, unit_label);
+  }
+
+  return 'No price';
+};
+
+export const formatPrice = (price: TPrice, currency: TPaymentCurrency, unit_label?: string, quantity: number = 1) => {
+  const amount = fromUnitToToken(new BN(price.unit_amount).mul(new BN(quantity)), currency.decimal).toString();
+  if (price?.type === 'recurring' && price.recurring) {
+    const recurring = formatRecurring(price.recurring, false, '/');
+
+    if (unit_label) {
+      return `${amount} ${currency.symbol} / ${unit_label} ${recurring}`;
+    }
+    if (price.recurring.usage_type === 'metered') {
+      return `${amount} ${currency.symbol} / unit ${recurring}`;
+    }
+
+    return `${amount} ${currency.symbol} ${recurring}`;
+  }
+
+  return `${amount} ${currency.symbol}`;
+};
+
+export function getPricingModel(price: TPrice) {
+  if (price.billing_scheme === 'tiered') {
+    return price.tiers_mode;
+  }
+
+  if (price.transform_quantity) {
+    return 'package';
+  }
+
+  return 'standard';
+}
+
+export function getProductByPriceId(products: TProductExpanded[], priceId: string) {
+  const product = cloneDeep(products.find((x) => x.prices.some((p) => p.id === priceId)));
+  if (product) {
+    product.prices = product.prices.filter((x) => x.id === priceId);
+  }
+  return product;
+}
+
+export function getStatementDescriptor(items: any[]) {
+  for (const item of items) {
+    if (item.price?.product?.statement_descriptor) {
+      return item.price?.product?.statement_descriptor;
+    }
+  }
+
+  return window.blocklet.appName;
+}
+
+export function formatRecurring(recurring: PriceRecurring, translate: boolean = true, separator = 'per') {
+  const intervals = {
+    hour: 'hourly',
+    day: 'daily',
+    week: 'weekly',
+    month: 'monthly',
+    year: 'yearly',
+  };
+
+  if (+recurring.interval_count === 1) {
+    // @ts-ignore
+    return translate ? intervals[recurring.interval] : `${separator} ${recurring.interval}`;
+  }
+
+  return `every ${recurring.interval_count} ${recurring.interval}s`;
+}
+
+export function formatLineItemPricing(
+  item: TLineItemExpanded,
+  currency: TPaymentCurrency,
+  trial: number
+): { primary: string; secondary?: string } {
+  const amount = fromUnitToToken(new BN(item.price.unit_amount).mul(new BN(item.quantity))).toString();
+
+  if (item.price.type === 'recurring' && item.price.recurring) {
+    if (trial > 0) {
+      const secondary = item.price.product.unit_label
+        ? `${amount} ${currency.symbol} / ${item.price.product.unit_label}`
+        : `${amount} ${currency.symbol}`;
+      return {
+        primary: `Free for ${trial} days`,
+        secondary: `${secondary} ${formatRecurring(item.price.recurring, false, '/')}`,
+      };
+    }
+
+    return {
+      primary: `${amount} ${currency.symbol}`,
+      secondary: item.price.product.unit_label ? `${amount} ${currency.symbol} / ${item.price.product.unit_label}` : '',
+    };
+  }
+
+  return {
+    primary: `${amount} ${currency.symbol}`,
+    secondary: item.price.product.unit_label ? `${amount} ${currency.symbol} / ${item.price.product.unit_label}` : '',
+  };
+}
+
+export function getCheckoutAmount(items: TLineItemExpanded[] = [], includeFreeTrial = false) {
+  const subtotal = items
+    .reduce((acc, x) => {
+      if (x.price.type === 'recurring') {
+        if (includeFreeTrial) {
+          return acc;
+        }
+        if (x.price.recurring?.usage_type === 'metered') {
+          return acc;
+        }
+      }
+      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    }, new BN(0))
+    .toString();
+
+  const total = items
+    .reduce((acc, x) => {
+      if (x.price.type === 'recurring') {
+        if (includeFreeTrial) {
+          return acc;
+        }
+        if (x.price.recurring?.usage_type === 'metered') {
+          return acc;
+        }
+      }
+      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    }, new BN(0))
+    .toString();
+
+  return { subtotal, total, discount: '0', shipping: '0', tax: '0' };
+}
+
+export function formatPaymentLinkPricing(link: TPaymentLinkExpanded, currency: TPaymentCurrency) {
+  const amount = getCheckoutAmount(link.line_items, !!link.subscription_data?.trial_period_days);
+  return formatCheckoutHeadlines({
+    mode: 'payment',
+    status: 'open',
+    payment_status: 'unpaid',
+    currency,
+    amount_total: amount.total,
+    amount_subtotal: amount.subtotal,
+    expires_at: dayjs().add(30, 'days').unix(),
+    ...link,
+  });
+}
+
+export function formatCheckoutHeadlines(session: TCheckoutSessionExpanded): {
+  action: string;
+  amount: string;
+  then?: string;
+  secondary?: string;
+} {
+  const items = session.line_items as TLineItemExpanded[];
+  const total = session.amount_total;
+  const trial = session.subscription_data?.trial_period_days || 0;
+  const currency = session.currency as TPaymentCurrency;
+
+  const brand = getStatementDescriptor(items);
+  const amount = `${fromUnitToToken(total, currency.decimal)} ${currency.symbol}`;
+
+  // empty
+  if (items.length === 0) {
+    throw new Error('No line items for the checkout session');
+  }
+
+  const { name } = items[0]?.price.product || { name: '' };
+
+  // all one time
+  if (items.every((x) => x.price.type === 'one_time')) {
+    if (items.length > 1) {
+      return { action: `Pay ${brand}`, amount };
+    }
+
+    return { action: `Pay ${brand}`, amount, then: '' };
+  }
+
+  const recurring = formatRecurring(
+    items.find((x) => x.price.type === 'recurring')?.price.recurring as PriceRecurring,
+    false
+  );
+
+  // all recurring
+  if (items.every((x) => x.price.type === 'recurring')) {
+    const hasMetered = items.some((x) => x.price.type === 'recurring' && x.price.recurring?.usage_type === 'metered');
+    const subscription = [
+      hasMetered ? 'continue with at least' : '',
+      fromUnitToToken(
+        items.reduce((acc, x) => {
+          if (x.price.recurring?.usage_type === 'metered') {
+            return acc;
+          }
+          return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+        }, new BN(0)),
+        currency.decimal
+      ),
+      currency.symbol,
+    ]
+      .filter(Boolean)
+      .join(' ');
+    if (items.length > 1) {
+      if (trial > 0) {
+        return {
+          action: `Try ${name} and ${items.length - 1} more`,
+          amount: `Free for ${trial} days`,
+          then: `Then ${subscription} ${recurring}`,
+        };
+      }
+
+      return {
+        action: `Subscribe to ${name} and ${items.length - 1} more`,
+        amount,
+        then: recurring,
+      };
+    }
+
+    if (trial > 0) {
+      return {
+        action: `Try ${name}`,
+        amount: `${trial} days free`,
+        then: `Then ${subscription} ${recurring}`,
+      };
+    }
+
+    return {
+      action: `Subscribe to ${name}`,
+      amount,
+      then: recurring,
+    };
+  }
+
+  // mixed
+  const subscription = fromUnitToToken(
+    items
+      .filter((x) => x.price.type === 'recurring')
+      .reduce((acc, x) => {
+        if (x.price.recurring?.usage_type === 'metered') {
+          return acc;
+        }
+        return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+      }, new BN(0)),
+    currency.decimal
+  );
+
+  return {
+    action: `Pay ${brand}`,
+    amount,
+    then: `Then ${subscription} ${currency.symbol} ${recurring}`,
+  };
+}
+
+export function getSubscriptionStatusColor(status: string) {
+  switch (status) {
+    case 'active':
+      return 'success';
+    case 'trialing':
+      return 'primary';
+    case 'incomplete':
+    case 'incomplete_expired':
+    case 'paused':
+      return 'warning';
+    case 'past_due':
+    case 'unpaid':
+      return 'error';
+    case 'canceled':
+    default:
+      return 'default';
+  }
+}
+
+export function getPaymentIntentStatusColor(status: string) {
+  switch (status) {
+    case 'succeeded':
+      return 'success';
+    case 'requires_payment_method':
+    case 'requires_confirmation':
+    case 'requires_action':
+    case 'requires_capture':
+      return 'warning';
+    case 'canceled':
+    case 'processing':
+    default:
+      return 'default';
+  }
+}
+
+export function getInvoiceStatusColor(status: string) {
+  switch (status) {
+    case 'paid':
+      return 'success';
+    case 'open':
+      return 'secondary';
+    case 'uncollectible':
+      return 'warning';
+    case 'draft':
+    case 'void':
+    default:
+      return 'default';
+  }
+}
+
+export function getWebhookStatusColor(status: string) {
+  switch (status) {
+    case 'enabled':
+      return 'success';
+    case 'disabled':
+    default:
+      return 'default';
+  }
+}
+
+export function isPriceRecurringAligned(list: LineItem[], products: TProductExpanded[], index: number) {
+  const prices = list.map((x) => {
+    const product = getProductByPriceId(products, x.price_id);
+    const price = product?.prices.find((p) => p.id === x.price_id);
+    return price;
+  });
+
+  if (prices[index]?.type !== 'recurring') {
+    return true;
+  }
+
+  const recurring = prices.slice(0, index).find((x) => x?.type === 'recurring')?.recurring;
+  if (!recurring) {
+    return true;
+  }
+
+  return prices.slice(0, index + 1).every((x: any) => {
+    if (x.type !== 'recurring') {
+      return true;
+    }
+
+    // If the interval and interval_count are different, the recurring is not aligned
+    if (recurring?.interval !== x.recurring?.interval || recurring?.interval_count !== x.recurring?.interval_count) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+export function formatSubscriptionProduct(items: TSubscriptionItemExpanded[], maxLength = 2) {
+  const names = items.map((x) => x.price.product.name);
+  return (
+    names.slice(0, maxLength).join(', ') + (names.length > maxLength ? ` and ${names.length - maxLength} more` : '')
+  );
+}
+
+export function formatAmount(amount: string, decimals: number, points = 2) {
+  return Number(fromUnitToToken(amount, decimals)).toFixed(points);
+}