@blocklet/payment-react 1.13.113

package/lib/types/shims.d.ts

@@ -0,0 +1,18 @@
+declare module '@arcblock/ux/*';
+declare module '@arcblock/did-connect/*';
+
+declare module '*.png';
+
+declare module 'google-libphonenumber';
+
+declare module 'flat';
+
+declare module '@arcblock/*';
+
+declare module '@blocklet/*';
+
+declare module 'pretty-ms-i18n';
+
+declare interface Window {
+  blocklet: any;
+}

package/lib/util.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import type { PriceCurrency, PriceRecurring, TCheckoutSessionExpanded, TLineItemExpanded, TPaymentCurrency, TPaymentMethodExpanded, TPrice, TSubscriptionExpanded } from '@blocklet/payment-types';
+export declare const PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+export declare const getPrefix: () => any;
+export declare function formatToDate(date: Date | string | number, locale?: string): any;
+export declare function formatToDatetime(date: Date | string | number, locale?: string): any;
+export declare function formatTime(date: Date | string | number, format?: string, locale?: string): any;
+export declare function formatDateTime(date: Date | string | number, locale?: string): any;
+export declare const formatLocale: (locale?: string) => string;
+export declare const formatPrettyMsLocale: (locale: string) => "zh_CN" | "en_US";
+export declare const formatError: (err: any) => any;
+export declare const formatPrice: (price: TPrice, currency: TPaymentCurrency, unit_label?: string, quantity?: number, bn?: boolean, locale?: string) => string;
+export declare const formatPriceAmount: (price: TPrice, currency: TPaymentCurrency, unit_label?: string, quantity?: number, bn?: boolean) => string;
+export declare function getStatementDescriptor(items: any[]): any;
+export declare function formatRecurring(recurring: PriceRecurring, translate?: boolean, separator?: string, locale?: string): string;
+export declare function getPriceUintAmountByCurrency(price: TPrice, currency: TPaymentCurrency): string;
+export declare function getPriceCurrencyOptions(price: TPrice): PriceCurrency[];
+export declare function formatLineItemPricing(item: TLineItemExpanded, currency: TPaymentCurrency, trial: number, locale?: string): {
+    primary: string;
+    secondary?: string;
+    quantity: string;
+};
+export declare function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, includeFreeTrial?: boolean, upsell?: boolean): {
+    subtotal: any;
+    total: any;
+    renew: any;
+    discount: string;
+    shipping: string;
+    tax: string;
+};
+export declare function getRecurringPeriod(recurring: PriceRecurring): number;
+export declare function formatUpsellSaving(session: TCheckoutSessionExpanded, currency: TPaymentCurrency): string;
+export declare function formatCheckoutHeadlines(session: TCheckoutSessionExpanded, currency: TPaymentCurrency, locale?: string): {
+    action: string;
+    amount: string;
+    then?: string;
+    secondary?: string;
+};
+export declare function formatAmount(amount: string, decimals: number): string;
+export declare function findCurrency(methods: TPaymentMethodExpanded[], currencyId: string): import("sequelize").InferAttributes<import("@blocklet/payment-types").PaymentCurrency, {
+    omit: never;
+}> | null;
+export declare function isValidCountry(code: string): boolean;
+export declare function stopEvent(e: React.SyntheticEvent<any>): void;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare const getSubscriptionTimeSummary: (subscription: TSubscriptionExpanded) => string;
+export declare const getSubscriptionAction: (subscription: TSubscriptionExpanded) => {
+    action: string;
+    variant: string;
+    color: string;
+} | null;
+export declare const mergeExtraParams: (extra?: Record<string, any>) => string;

package/lib/util.js

@@ -0,0 +1,487 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PAYMENT_KIT_DID = void 0;
+exports.findCurrency = findCurrency;
+exports.formatAmount = formatAmount;
+exports.formatCheckoutHeadlines = formatCheckoutHeadlines;
+exports.formatDateTime = formatDateTime;
+exports.formatError = void 0;
+exports.formatLineItemPricing = formatLineItemPricing;
+exports.formatPriceAmount = exports.formatPrice = exports.formatPrettyMsLocale = exports.formatLocale = void 0;
+exports.formatRecurring = formatRecurring;
+exports.formatTime = formatTime;
+exports.formatToDate = formatToDate;
+exports.formatToDatetime = formatToDatetime;
+exports.formatUpsellSaving = formatUpsellSaving;
+exports.getCheckoutAmount = getCheckoutAmount;
+exports.getPrefix = void 0;
+exports.getPriceCurrencyOptions = getPriceCurrencyOptions;
+exports.getPriceUintAmountByCurrency = getPriceUintAmountByCurrency;
+exports.getRecurringPeriod = getRecurringPeriod;
+exports.getStatementDescriptor = getStatementDescriptor;
+exports.getSubscriptionTimeSummary = exports.getSubscriptionAction = void 0;
+exports.isValidCountry = isValidCountry;
+exports.mergeExtraParams = void 0;
+exports.sleep = sleep;
+exports.stopEvent = stopEvent;
+var _util = require("@ocap/util");
+var _reactInternationalPhone = require("react-international-phone");
+var _dayjs = _interopRequireDefault(require("./dayjs"));
+var _index = require("./locales/index");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const PAYMENT_KIT_DID = exports.PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+const getPrefix = () => {
+  const componentId = (window.blocklet.componentId || "").split("/").pop();
+  if (componentId === PAYMENT_KIT_DID) {
+    return window.blocklet.prefix;
+  }
+  const component = (window.blocklet.componentMountPoints || []).find(x => x.did === PAYMENT_KIT_DID);
+  if (component) {
+    return component.mountPoint;
+  }
+  return window.blocklet.prefix;
+};
+exports.getPrefix = getPrefix;
+function formatToDate(date, locale = "en") {
+  if (!date) {
+    return "-";
+  }
+  return (0, _dayjs.default)(date).locale(formatLocale(locale)).format("YYYY-MM-DD HH:mm:ss");
+}
+function formatToDatetime(date, locale = "en") {
+  if (!date) {
+    return "-";
+  }
+  return (0, _dayjs.default)(date).locale(formatLocale(locale)).format("lll");
+}
+function formatTime(date, format = "YYYY-MM-DD HH:mm:ss", locale = "en") {
+  if (!date) {
+    return "-";
+  }
+  return (0, _dayjs.default)(date).locale(formatLocale(locale)).format(format);
+}
+function formatDateTime(date, locale = "en") {
+  return (0, _dayjs.default)(date).locale(formatLocale(locale)).format("YYYY-MM-DD HH:mm");
+}
+const formatLocale = (locale = "en") => {
+  if (locale === "tw") {
+    return "zh";
+  }
+  return locale;
+};
+exports.formatLocale = formatLocale;
+const formatPrettyMsLocale = locale => locale === "zh" ? "zh_CN" : "en_US";
+exports.formatPrettyMsLocale = formatPrettyMsLocale;
+const formatError = err => {
+  const {
+    details,
+    errors,
+    response
+  } = err;
+  if (Array.isArray(errors)) {
+    return errors.map(x => x.message).join("\n");
+  }
+  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(";")}`;
+  }
+  if (response) {
+    return response.data.error || `${err.message}: ${JSON.stringify(response.data)}`;
+  }
+  return err.message;
+};
+exports.formatError = formatError;
+const formatPrice = (price, currency, unit_label, quantity = 1, bn = true, locale = "en") => {
+  const unit = getPriceUintAmountByCurrency(price, currency);
+  const amount = bn ? (0, _util.fromUnitToToken)(new _util.BN(unit).mul(new _util.BN(quantity)), currency.decimal).toString() : +unit * quantity;
+  if (price?.type === "recurring" && price.recurring) {
+    const recurring = formatRecurring(price.recurring, false, "slash", locale);
+    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}`;
+};
+exports.formatPrice = formatPrice;
+const formatPriceAmount = (price, currency, unit_label, quantity = 1, bn = true) => {
+  const unit = getPriceUintAmountByCurrency(price, currency);
+  const amount = bn ? (0, _util.fromUnitToToken)(new _util.BN(unit).mul(new _util.BN(quantity)), currency.decimal).toString() : +unit * quantity;
+  if (price?.type === "recurring" && price.recurring) {
+    if (unit_label) {
+      return `${amount} ${currency.symbol} / ${unit_label}`;
+    }
+    if (price.recurring.usage_type === "metered") {
+      return `${amount} ${currency.symbol} / unit`;
+    }
+    return `${amount} ${currency.symbol}`;
+  }
+  return `${amount} ${currency.symbol}`;
+};
+exports.formatPriceAmount = formatPriceAmount;
+function getStatementDescriptor(items) {
+  for (const item of items) {
+    if (item.price?.product?.statement_descriptor) {
+      return item.price?.product?.statement_descriptor;
+    }
+  }
+  return window.blocklet.appName;
+}
+function formatRecurring(recurring, translate = true, separator = "per", locale = "en") {
+  const intervals = {
+    hour: "hourly",
+    day: "daily",
+    week: "weekly",
+    month: "monthly",
+    year: "yearly"
+  };
+  if (+recurring.interval_count === 1) {
+    const interval = (0, _index.t)(`common.${recurring.interval}`, locale);
+    return translate ? (0, _index.t)(`common.${intervals[recurring.interval]}`, locale) : separator ? (0, _index.t)(`common.${separator}`, locale, {
+      interval
+    }) : interval;
+  }
+  return (0, _index.t)("common.recurring", locale, {
+    count: recurring.interval_count,
+    interval: (0, _index.t)(`common.${recurring.interval}s`, locale)
+  });
+}
+function getPriceUintAmountByCurrency(price, currency) {
+  const options = getPriceCurrencyOptions(price);
+  const option = options.find(x => x.currency_id === currency.id);
+  if (option) {
+    return option.unit_amount;
+  }
+  return price.unit_amount;
+}
+function getPriceCurrencyOptions(price) {
+  if (Array.isArray(price.currency_options)) {
+    return price.currency_options;
+  }
+  return [{
+    currency_id: price.currency_id,
+    unit_amount: price.unit_amount,
+    tiers: null,
+    custom_unit_amount: null
+  }];
+}
+function formatLineItemPricing(item, currency, trial, locale = "en") {
+  const price = item.upsell_price || item.price;
+  let quantity = (0, _index.t)("common.qty", locale, {
+    count: item.quantity
+  });
+  if (price.recurring?.usage_type === "metered" || +item.quantity === 1) {
+    quantity = "";
+  }
+  const total = `${(0, _util.fromUnitToToken)(new _util.BN(getPriceUintAmountByCurrency(price, currency)).mul(new _util.BN(item.quantity)), currency.decimal)} ${currency.symbol}`;
+  const unit = `${(0, _util.fromUnitToToken)(getPriceUintAmountByCurrency(price, currency))} ${currency.symbol}`;
+  const appendUnit = (v, alt) => {
+    if (price.product.unit_label) {
+      return `${v}/${price.product.unit_label}`;
+    }
+    if (price.recurring?.usage_type === "metered" || item.quantity === 1) {
+      return alt;
+    }
+    return quantity ? (0, _index.t)("common.each", locale, {
+      unit
+    }) : "";
+  };
+  if (price.type === "recurring" && price.recurring) {
+    if (trial > 0) {
+      return {
+        primary: (0, _index.t)("common.trial", locale, {
+          count: trial
+        }),
+        secondary: `${appendUnit(total, total)} ${formatRecurring(price.recurring, false, "slash", locale)}`,
+        quantity
+      };
+    }
+    return {
+      primary: total,
+      secondary: appendUnit(total, ""),
+      quantity
+    };
+  }
+  return {
+    primary: total,
+    secondary: appendUnit(total, ""),
+    quantity
+  };
+}
+function getCheckoutAmount(items, currency, includeFreeTrial = false, upsell = true) {
+  let renew = new _util.BN(0);
+  const total = items.reduce((acc, x) => {
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    if (price.type === "recurring") {
+      renew = renew.add(new _util.BN(getPriceUintAmountByCurrency(price, currency)).mul(new _util.BN(x.quantity)));
+      if (includeFreeTrial) {
+        return acc;
+      }
+      if (price.recurring?.usage_type === "metered") {
+        return acc;
+      }
+    }
+    return acc.add(new _util.BN(getPriceUintAmountByCurrency(price, currency)).mul(new _util.BN(x.quantity)));
+  }, new _util.BN(0)).toString();
+  return {
+    subtotal: total,
+    total,
+    renew: renew.toString(),
+    discount: "0",
+    shipping: "0",
+    tax: "0"
+  };
+}
+function getRecurringPeriod(recurring) {
+  const {
+    interval
+  } = recurring;
+  const count = +recurring.interval_count || 1;
+  const dayInMs = 24 * 60 * 60 * 1e3;
+  switch (interval) {
+    case "hour":
+      return 60 * 60 * 1e3;
+    case "day":
+      return count * dayInMs;
+    case "week":
+      return count * 7 * dayInMs;
+    case "month":
+      return count * 30 * dayInMs;
+    case "year":
+      return count * 365 * dayInMs;
+    default:
+      throw new Error(`Unsupported recurring interval: ${interval}`);
+  }
+}
+function formatUpsellSaving(session, currency) {
+  const items = session.line_items;
+  if (items[0]?.upsell_price_id) {
+    return "0";
+  }
+  if (!items[0]?.price.upsell?.upsells_to) {
+    return "0";
+  }
+  const from = getCheckoutAmount(items, currency, false, false);
+  const to = getCheckoutAmount(items.map(x => ({
+    ...x,
+    upsell_price_id: x.price.upsell?.upsells_to_id,
+    upsell_price: x.price.upsell?.upsells_to
+  })), currency, false, true);
+  const fromRecurring = items[0].price?.recurring;
+  const toRecurring = items[0].price?.upsell?.upsells_to?.recurring;
+  if (!fromRecurring || !toRecurring) {
+    return "0";
+  }
+  const factor = Math.floor(getRecurringPeriod(toRecurring) / getRecurringPeriod(fromRecurring));
+  const before = new _util.BN(from.total).mul(new _util.BN(factor));
+  const after = new _util.BN(to.total);
+  return Number(before.sub(after).mul(new _util.BN(100)).div(before).toString()).toFixed(0);
+}
+function formatCheckoutHeadlines(session, currency, locale = "en") {
+  const items = session.line_items;
+  const trial = session.subscription_data?.trial_period_days || 0;
+  const brand = getStatementDescriptor(items);
+  const {
+    total
+  } = getCheckoutAmount(items, currency, !!trial);
+  const amount = `${(0, _util.fromUnitToToken)(total, currency.decimal)} ${currency.symbol}`;
+  if (items.length === 0) {
+    return {
+      action: (0, _index.t)("payment.checkout.empty", locale),
+      amount: "0",
+      then: ""
+    };
+  }
+  const {
+    name
+  } = items[0]?.price.product || {
+    name: ""
+  };
+  if (items.every(x => x.price.type === "one_time")) {
+    const action = (0, _index.t)("payment.checkout.pay", locale, {
+      payee: brand
+    });
+    if (items.length > 1) {
+      return {
+        action,
+        amount
+      };
+    }
+    return {
+      action,
+      amount,
+      then: ""
+    };
+  }
+  const item = items.find(x => x.price.type === "recurring");
+  const recurring = formatRecurring((item?.upsell_price || item?.price)?.recurring, false, "per", locale);
+  if (items.every(x => x.price.type === "recurring")) {
+    const hasMetered = items.some(x => x.price.type === "recurring" && x.price.recurring?.usage_type === "metered");
+    const subscription2 = [hasMetered ? (0, _index.t)("payment.checkout.least", locale) : "", (0, _util.fromUnitToToken)(items.reduce((acc, x) => {
+      if (x.price.recurring?.usage_type === "metered") {
+        return acc;
+      }
+      return acc.add(new _util.BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new _util.BN(x.quantity)));
+    }, new _util.BN(0)), currency.decimal), currency.symbol].filter(Boolean).join(" ");
+    if (items.length > 1) {
+      if (trial > 0) {
+        return {
+          action: (0, _index.t)("payment.checkout.try2", locale, {
+            name,
+            count: items.length - 1
+          }),
+          amount: (0, _index.t)("payment.checkout.free", locale, {
+            count: trial
+          }),
+          then: (0, _index.t)("payment.checkout.then", locale, {
+            subscription: subscription2,
+            recurring
+          })
+        };
+      }
+      return {
+        action: (0, _index.t)("payment.checkout.sub2", locale, {
+          name,
+          count: items.length - 1
+        }),
+        amount,
+        then: recurring
+      };
+    }
+    if (trial > 0) {
+      return {
+        action: (0, _index.t)("payment.checkout.try1", locale, {
+          name
+        }),
+        amount: (0, _index.t)("payment.checkout.free", locale, {
+          count: trial
+        }),
+        then: (0, _index.t)("payment.checkout.then", locale, {
+          subscription: subscription2,
+          recurring
+        })
+      };
+    }
+    return {
+      action: (0, _index.t)("payment.checkout.sub1", locale, {
+        name
+      }),
+      amount,
+      then: recurring
+    };
+  }
+  const subscription = (0, _util.fromUnitToToken)(items.filter(x => x.price.type === "recurring").reduce((acc, x) => {
+    if (x.price.recurring?.usage_type === "metered") {
+      return acc;
+    }
+    return acc.add(new _util.BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new _util.BN(x.quantity)));
+  }, new _util.BN(0)), currency.decimal);
+  return {
+    action: (0, _index.t)("payment.checkout.pay", locale, {
+      payee: brand
+    }),
+    amount,
+    then: (0, _index.t)("payment.checkout.then", locale, {
+      subscription: `${subscription} ${currency.symbol}`,
+      recurring
+    })
+  };
+}
+function formatAmount(amount, decimals) {
+  return (0, _util.fromUnitToToken)(amount, decimals);
+}
+function findCurrency(methods, currencyId) {
+  for (const method of methods) {
+    for (const currency of method.payment_currencies) {
+      if (currency.id === currencyId) {
+        return currency;
+      }
+    }
+  }
+  return null;
+}
+function isValidCountry(code) {
+  return _reactInternationalPhone.defaultCountries.some(x => x[1] === code);
+}
+function stopEvent(e) {
+  try {
+    e.stopPropagation();
+    e.preventDefault();
+  } catch {}
+}
+function sleep(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+const getSubscriptionTimeSummary = subscription => {
+  const lines = [`Started on ${formatToDate(subscription.start_date * 1e3)}`];
+  if (subscription.status === "active" || subscription.status === "trialing") {
+    if (subscription.cancel_at) {
+      lines.push(`will cancel on ${formatToDate(subscription.cancel_at * 1e3)}`);
+    } else if (subscription.cancel_at_period_end) {
+      lines.push(`will cancel on ${formatToDate(subscription.current_period_end * 1e3)}`);
+    } else {
+      lines.push(`will renew on ${formatToDate(subscription.current_period_end * 1e3)}`);
+    }
+  } else if (subscription.status === "past_due") {
+    lines.push(`will cancel on ${formatToDate(subscription.current_period_end * 1e3)}`);
+  } else if (subscription.status === "canceled") {
+    lines.push(`canceled on ${formatToDate(subscription.canceled_at * 1e3)}`);
+  }
+  return lines.join(", ");
+};
+exports.getSubscriptionTimeSummary = getSubscriptionTimeSummary;
+const getSubscriptionAction = subscription => {
+  if (subscription.status !== "canceled" && subscription.cancel_at_period_end) {
+    return {
+      action: "recover",
+      variant: "contained",
+      color: "primary"
+    };
+  }
+  if (subscription.status === "active" || subscription.status === "trialing") {
+    if (subscription.cancel_at) {
+      return null;
+    }
+    if (subscription.cancel_at_period_end) {
+      return {
+        action: "recover",
+        variant: "contained",
+        color: "primary"
+      };
+    }
+    return {
+      action: "cancel",
+      variant: "outlined",
+      color: "inherit"
+    };
+  }
+  if (subscription.status === "past_due") {
+    return {
+      action: "pastDue",
+      variant: "contained",
+      color: "primary"
+    };
+  }
+  return null;
+};
+exports.getSubscriptionAction = getSubscriptionAction;
+const mergeExtraParams = (extra = {}) => {
+  const params = new URLSearchParams(window.location.search);
+  Object.keys(extra).forEach(key => {
+    params.set(key, extra[key]);
+  });
+  return params.toString();
+};
+exports.mergeExtraParams = mergeExtraParams;

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@blocklet/payment-react",
+  "version": "1.13.113",
+  "description": "Reusable react components for payment kit v2",
+  "keywords": [
+    "react",
+    "payment"
+  ],
+  "author": "wangshijun<wangshijun2010@gmail.com>",
+  "homepage": "https://github.com/blocklet/payment-kit#readme",
+  "license": "Apache-2.0",
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/blocklet/payment-kit.git"
+  },
+  "scripts": {
+    "lint": "tsc --noEmit && eslint src tests --ext js --ext jsx --ext ts --ext tsx",
+    "lint:fix": "npm run lint -- --fix",
+    "build": "tsc --noEmit && unbuild && node tools/auto-exports.js",
+    "watch": "CONSOLA_LEVEL=1 nodemon -e .jsx,.js,.ts,.tsx -w src -x 'yalc publish --push'",
+    "precommit": "CI=1 npm run lint",
+    "prepush": "CI=1 npm run lint",
+    "prepublish": "npm run build",
+    "test": "node tools/jest.js",
+    "coverage": "npm run test -- --coverage"
+  },
+  "bugs": {
+    "url": "https://github.com/blocklet/payment-kit/issues"
+  },
+  "exports": {
+    ".": {
+      "import": "./es/index.js",
+      "require": "./lib/index.js"
+    },
+    "./lib/": {
+      "import": "./es/",
+      "require": "./lib/"
+    }
+  },
+  "importSort": {
+    ".js, .jsx, .mjs": {
+      "parser": "babylon",
+      "style": "module"
+    },
+    ".ts, .tsx": {
+      "style": "module",
+      "parser": "typescript"
+    }
+  },
+  "dependencies": {
+    "@arcblock/did-connect": "^2.9.15",
+    "@arcblock/ux": "^2.9.15",
+    "@mui/icons-material": "^5.15.6",
+    "@mui/lab": "^5.0.0-alpha.162",
+    "@mui/material": "^5.15.6",
+    "@mui/styles": "^5.15.6",
+    "@mui/system": "^5.15.6",
+    "@ocap/util": "^1.18.108",
+    "@stripe/react-stripe-js": "^2.4.0",
+    "@stripe/stripe-js": "^2.2.0",
+    "ahooks": "^3.7.8",
+    "axios": "^0.27.2",
+    "dayjs": "^1.11.10",
+    "flat": "^5.0.2",
+    "google-libphonenumber": "^3.2.33",
+    "lodash": "^4.17.21",
+    "p-wait-for": "3",
+    "react-error-boundary": "^4.0.11",
+    "react-hook-form": "^7.48.2",
+    "react-international-phone": "^3.1.2",
+    "ufo": "^1.3.2",
+    "use-bus": "^2.5.2",
+    "validator": "^13.11.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@arcblock/eslint-config-ts": "^0.2.4",
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.19.3",
+    "@babel/preset-env": "^7.19.3",
+    "@babel/preset-react": "^7.18.6",
+    "@blocklet/payment-types": "1.13.113",
+    "@types/react": "^18.2.42",
+    "@types/react-dom": "^18.2.17",
+    "eslint": "^8.56.0",
+    "glob": "^10.3.3",
+    "import-sort-style-module": "^6.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^2.8.8",
+    "prettier-plugin-import-sort": "^0.0.7",
+    "ts-jest": "^29.1.2",
+    "type-fest": "^4.8.3",
+    "typescript": "^4.9.5",
+    "unbuild": "^2.0.0"
+  },
+  "gitHead": "d1a99d9bbdb06d4e7742d7741ec511fa0fee4663"
+}

package/src/api.ts

@@ -0,0 +1,24 @@
+import { getLocale } from '@arcblock/ux/lib/Locale/context';
+import axios from 'axios';
+import isNull from 'lodash/isNull';
+
+import { getPrefix } from './util';
+
+const api = axios.create();
+
+api.interceptors.request.use(
+  (config) => {
+    const prefix = getPrefix();
+    config.baseURL = prefix || '';
+    config.timeout = 8000;
+
+    const livemode = localStorage.getItem('livemode');
+    const locale = getLocale(window.blocklet.languages);
+    config.params = { ...(config.params || {}), livemode: isNull(livemode) ? true : JSON.parse(livemode), locale };
+
+    return config;
+  },
+  (err) => Promise.reject(err)
+);
+
+export default api;