@abtnode/ux 1.16.14-beta-ab7f615e → 1.16.14-beta-cb53c14b

package/es/util/index.js

@@ -0,0 +1,598 @@
+/* eslint-disable max-len */
+/* eslint-disable implicit-arrow-linebreak */
+/* eslint-disable import/prefer-default-export */
+import { DEFAULT_IP_DOMAIN_SUFFIX, DEFAULT_DID_DOMAIN, DOMAIN_FOR_IP_SITE, DOMAIN_FOR_IP_SITE_REGEXP, DOMAIN_FOR_DEFAULT_SITE, DOMAIN_FOR_INTERNAL_SITE, ROLES, WELLKNOWN_SERVICE_PATH_PREFIX, WELLKNOWN_PING_PREFIX, IP, SLOT_FOR_IP_DNS_SITE, WELLKNOWN_PATH_PREFIX, WEB_WALLET_URL, BLOCKLET_STORE_API_PREFIX } from '@abtnode/constant';
+import qs from 'querystring';
+import isUrl from 'is-url';
+import humanizeUrl from 'humanize-url';
+import filesize from 'filesize';
+import joinUrl from 'url-join';
+import get from 'lodash/get';
+import last from 'lodash/last';
+import trimEnd from 'lodash/trimEnd';
+import { BLOCKLET_MODES } from '@blocklet/constant';
+import { evaluateURLs, isDidDomain, isIpEcho, isSlpDomain } from '@abtnode/util/lib/url-evaluation';
+import checkAccessible from '@abtnode/util/lib/url-evaluation/check-accessible-browser';
+import axios from '@abtnode/util/lib/axios';
+import normalizePathPrefix from '@abtnode/util/lib/normalize-path-prefix';
+import urlPathFriendly from '@blocklet/meta/lib/url-path-friendly';
+import formatError from '@abtnode/util/lib/format-error';
+import dayjs from '@abtnode/util/lib/dayjs';
+export { formatError };
+export function sleep(t) {
+  // eslint-disable-next-line no-promise-executor-return
+  return new Promise(resolve => setTimeout(resolve, t));
+}
+export const validateDomain = (domain, locale = 'en') => {
+  if (!domain) {
+    return {
+      en: 'Site domain cannot be empty',
+      zh: '站点域名不能为空'
+    }[locale];
+  }
+  if (domain.endsWith(DEFAULT_IP_DOMAIN_SUFFIX)) {
+    return {
+      en: `Site domain cannot include ${DEFAULT_IP_DOMAIN_SUFFIX}`,
+      zh: `站点域名不能包含 ${DEFAULT_IP_DOMAIN_SUFFIX}`
+    }[locale];
+  }
+  return null;
+};
+
+/**
+ * get access url
+ * auto fix http/https, port, query
+ * docker friendly
+ */
+export function getAccessUrl(hostname, path = '', params = undefined) {
+  if (!hostname) {
+    return '';
+  }
+  let protocol = 'http';
+  if (window.location.protocol === 'https:') {
+    if (isIpEcho(hostname) || isSlpDomain(hostname) || isDidDomain(hostname)) {
+      protocol = 'https';
+    }
+  }
+  let port = '';
+  const browserPort = Number(window.location.port);
+  if (process.env.NODE_ENV !== 'development' && browserPort && ![80, 443].includes(browserPort)) {
+    port = `:${browserPort}`;
+  }
+  const urlObj = new URL(`${protocol}://${hostname}${port}`);
+  urlObj.pathname = path;
+  const url = urlObj.href.replace(/\/$/, '');
+  if (!params || !Object.keys(params)) {
+    return url;
+  }
+  const searchParams = new URLSearchParams();
+  Object.keys(params).forEach(key => {
+    searchParams.append(key, params[key]);
+  });
+  return `${url}${urlObj.pathname === '/' ? '/' : ''}?${searchParams.toString()}`;
+}
+export function getBlockletUrl({
+  blocklet,
+  domain: inputDomain,
+  mountPoint: inputMountPoint,
+  params
+} = {}) {
+  const {
+    site
+  } = blocklet;
+  if (!site) {
+    return null;
+  }
+  const domain = inputDomain || (site.domainAliases || [])[0];
+  if (!domain) {
+    return null;
+  }
+  let mountPoint = inputMountPoint;
+  if (!mountPoint) {
+    const rule = site.rules.filter(x => !x.from.pathPrefix.startsWith(WELLKNOWN_PATH_PREFIX))[0];
+    mountPoint = rule ? rule.from.pathPrefix : '/';
+  }
+  return getAccessUrl(domain.value, mountPoint, params);
+}
+export function getBlockletUrls({
+  blocklet,
+  mountPoint: inputMountPoint,
+  params
+} = {}) {
+  const {
+    site
+  } = blocklet;
+  if (!site) {
+    return [];
+  }
+  const domains = site.domainAliases || [];
+  if (!domains.length) {
+    return [];
+  }
+  let mountPoint = inputMountPoint;
+  if (!mountPoint) {
+    const rules = site.rules.filter(x => !x.from.pathPrefix.startsWith(WELLKNOWN_PATH_PREFIX));
+    let rule = rules[0];
+    if (rule?.from?.pathPrefix !== '/') {
+      const rootRule = rules.find(x => x.from?.pathPrefix === '/');
+      if (rootRule) {
+        rule = rootRule;
+      }
+    }
+    mountPoint = normalizePathPrefix(rule?.from?.pathPrefix || '/');
+  }
+  return domains.map(domain => getAccessUrl(domain.value, mountPoint, params));
+}
+export function getExplorerLink(chainHost, did, type) {
+  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 patchJsxToLocale(rawStr, replaceMap = {}) {
+  return rawStr.split(/{{|}}/).map(item => {
+    if (replaceMap[item]) {
+      if (replaceMap[item] instanceof Function) {
+        return replaceMap[item]();
+      }
+      return replaceMap[item];
+    }
+    return item;
+  }).filter(Boolean);
+}
+export function formatToDate(date, locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+  return dayjs(date).locale(formatLocale(locale)).format('ll');
+}
+export function formatToDatetime(date, locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+  return dayjs(date).locale(formatLocale(locale)).format('lll');
+}
+export function formatTime(date, format = 'lll', locale = 'en') {
+  if (!date) {
+    return '-';
+  }
+  return dayjs(date).locale(formatLocale(locale)).format(format);
+}
+export function formatDateTime(date, 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 => locale === 'zh' ? 'zh_CN' : 'en_US';
+export const parseQuery = str => str.replace(/^\?/, '').split('&').map(x => x.split('=')).filter(([key]) => !!key).reduce((memo, x) => {
+  const key = x[0];
+  const value = decodeURIComponent(x[1]) || true;
+  memo[key] = value;
+  return memo;
+}, {});
+
+// Append any query string url to api requests
+export const appendParams = (url, extraParams = {}) => {
+  const [pathname, query = ''] = url.split('?');
+  const oldParams = parseQuery(query);
+  const params = Object.assign({}, oldParams, extraParams);
+  return `${pathname}?${qs.stringify(params)}`;
+};
+export const isInstalling = status => ['waiting', 'downloading', 'installing', 'upgrading'].includes(status);
+export const isDownloading = status => ['waiting', 'downloading'].includes(status);
+export const isRunning = status => status === 'running';
+export const formatDiskSize = (size, serverPlatform = '') => {
+  const base = serverPlatform === 'linux' ? 2 : 10;
+  return filesize(size, {
+    base,
+    round: 2
+  });
+};
+export const checkInputByType = (type, value) => {
+  const typesMap = {
+    url: isUrl
+  };
+  if (!type) {
+    return true;
+  }
+  if (typesMap[type]) {
+    return typesMap[type](value);
+  }
+  return false;
+};
+export const formatUrl = url => humanizeUrl(url.split('?').shift());
+export const formatPerson = person => {
+  if (!person) {
+    return '-';
+  }
+  if (typeof person === 'string') {
+    return person;
+  }
+  const name = person.name || '';
+  const u = person.url || person.web;
+  const url = u ? ` (${u})` : '';
+  const e = person.email || person.mail;
+  const email = e ? ` <${e}>` : '';
+  return name + email + url;
+};
+export const shouldCheckDomainStatus = domain => domain &&
+// eslint-disable-line
+![DOMAIN_FOR_IP_SITE, DOMAIN_FOR_IP_SITE_REGEXP, DOMAIN_FOR_DEFAULT_SITE, DOMAIN_FOR_INTERNAL_SITE].includes(domain);
+export const checkIsWildcardDomain = url => {
+  try {
+    if (!url) {
+      return false;
+    }
+    const tempUrl = url.startsWith('http') ? url : `http://${url}`;
+    const urlObj = new window.URL(tempUrl);
+    return decodeURIComponent(urlObj.host).split('.').some(x => x === '*');
+  } catch (error) {
+    console.error(url, error);
+    return false;
+  }
+};
+export const stringSortHandlerAsc = (strA = '', strB = '') => {
+  if (strA > strB) {
+    return 1;
+  }
+  if (strB > strA) {
+    return -1;
+  }
+  return 0;
+};
+export const getInviteLink = ({
+  inviteId,
+  endpoint
+}) => {
+  if (!endpoint) {
+    return '';
+  }
+  const u = new URL(endpoint);
+  u.pathname = joinUrl(u.pathname, WELLKNOWN_SERVICE_PATH_PREFIX, 'invite');
+  u.searchParams.set('inviteId', inviteId);
+  return u.href;
+};
+export const getTransferAppLink = ({
+  transferId,
+  endpoint
+}) => {
+  if (!endpoint) {
+    return '';
+  }
+  const u = new URL(endpoint);
+  u.pathname = joinUrl(u.pathname, WELLKNOWN_SERVICE_PATH_PREFIX, 'transfer');
+  u.searchParams.set('transferId', transferId);
+  return u.href;
+};
+export const getIssuePassportLink = ({
+  id,
+  endpoint
+}) => {
+  if (!endpoint) {
+    return '';
+  }
+  const u = new URL(endpoint);
+  u.pathname = joinUrl(u.pathname, WELLKNOWN_SERVICE_PATH_PREFIX, 'issue-passport');
+  u.searchParams.set('id', id);
+  return u.href;
+};
+export const formatRegistryScreenshotPath = (did, asset) => {
+  if (asset.startsWith('/assets')) {
+    return asset;
+  }
+  return `/assets/${did}/screenshots/${asset}`;
+};
+export const formatRegistryLogoPath = (did, asset) => {
+  if (asset.startsWith('/assets')) {
+    return asset;
+  }
+  return `/assets/${did}/${asset}`;
+};
+export function getWebWalletUrl(info) {
+  try {
+    const url = window.localStorage.getItem('wallet_url');
+    if (url) {
+      return url;
+    }
+  } catch (err) {
+    // Do nothing
+  }
+  return info && info.webWalletUrl ? info.webWalletUrl : WEB_WALLET_URL;
+}
+export function isValidClusterSize(data) {
+  const {
+    value,
+    cpuCores
+  } = data;
+  if (!value) {
+    return '';
+  }
+  const v = Number(value);
+  if (Number.isNaN(v)) {
+    return 'Cluster size should be a number';
+  }
+  if (!Number.isInteger(v)) {
+    return 'Cluster size should be integer';
+  }
+  if (v <= 0 || v > cpuCores) {
+    return `Cluster size should between 1 to ${cpuCores}`;
+  }
+  return '';
+}
+export function isProtectedRole(role) {
+  return Object.values(ROLES).includes(role);
+}
+export function formatFactoryPrice(blocklet) {
+  if (!blocklet?.payment) {
+    return [];
+  }
+  const list = (blocklet.payment?.price || []).map(item => ({
+    name: item.symbol,
+    value: item.value
+  }));
+  return list;
+}
+export const getBlockletLogoUrl = ({
+  did,
+  baseUrl,
+  logoPath
+}) => {
+  if (logoPath && logoPath.startsWith('http')) {
+    return logoPath;
+  }
+  if (baseUrl.startsWith('http') && logoPath) {
+    return joinUrl(baseUrl, formatRegistryLogoPath(did, logoPath));
+  }
+  const prefix = window.env.apiPrefix || '/';
+  let apiPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+  if (apiPrefix) {
+    apiPrefix = `/${apiPrefix}`;
+  }
+  return joinUrl(apiPrefix, `/blocklet/logo/${did}`);
+};
+export const getPathPrefix = () => window.env && window.env.apiPrefix ? window.env.apiPrefix : '/';
+export const isUrlAccessible = url => checkAccessible(joinUrl(new URL(url).origin, WELLKNOWN_PING_PREFIX));
+export const getAccessibleUrl = async urls => {
+  try {
+    const res = await evaluateURLs(urls);
+    return res[0].url;
+  } catch (error) {
+    console.warn('get accessible url failed');
+    return '';
+  }
+};
+
+/**
+ * 检查证书是否与 blocklet 匹配
+ * @param {string[]} blockletUrls - 通过 blocklet#interfaces#url 获取到的一组 url
+ * @param {object[]} matchedSites - 通过 certificate#matchedSites 获取到的一组 site
+ * @returns {boolean} - 匹配则返回 true
+ */
+export const isCertificateMatch = (blockletUrls = [], matchedSites = []) => {
+  try {
+    return matchedSites.map(item => item.domain).some(domain => {
+      return blockletUrls.some(u => {
+        const url = new window.URL(u.startsWith('http') ? u : `http://${u}`);
+        return url.hostname === domain;
+      });
+    });
+  } catch (e) {
+    console.warn('domain match failed');
+    return false;
+  }
+};
+export const getBlockletUrlParams = (blocklet, locale) => (blocklet || {}).status === 'running' ? {
+  locale
+} : {
+  locale,
+  __start__: 1
+};
+
+/**
+ * 判断是否在safari浏览器中
+ * 不传的ua情况下，使用当前页面的ua
+ * chrome浏览器的ua也会带有 Safari 字样，所以要排除 Chrome 字符串
+ * iPhone 设备下，所有浏览器都是 safari 的 webkit
+ * @param {String} ua userAgent 字符串
+ * @returns bool
+ */
+export const isSafari = (ua = window.navigator.userAgent) => {
+  return ua.includes('iPhone') || ua.includes('Safari') && !ua.includes('Chrome');
+};
+export const isChrome = (ua = window.navigator.userAgent) => {
+  return ua.includes('Chrome');
+};
+
+/**
+ *
+ * @export
+ * @param {string} url
+ * @return {string}
+ */
+export function deepDecodeURIComponent(url) {
+  let lastDecodeUrl = decodeURIComponent(url);
+  while (lastDecodeUrl !== decodeURIComponent(lastDecodeUrl)) {
+    lastDecodeUrl = decodeURIComponent(lastDecodeUrl);
+  }
+  return lastDecodeUrl;
+}
+
+/**
+ *
+ * @description 已知nextWorkflow的地址,提取它的statusUrl和token
+ * @export
+ * @param {string} nextWorkflow
+ * @returns {{
+ *  statusUrl: string;
+ *  token: string;
+ * }}
+ */
+export function extractStatusUrlFromNextWorkflow(nextWorkflow) {
+  const nextWorkflowURL = new URL(deepDecodeURIComponent(nextWorkflow)).searchParams.get('url');
+  return {
+    statusUrl: nextWorkflowURL.replace('/auth?', '/status?'),
+    token: new URL(nextWorkflowURL).searchParams.get('_t_')
+  };
+}
+export function getBlockletMetaUrl(storeUrl, did) {
+  return joinUrl(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json`);
+}
+export async function getAsset(chainHost, address) {
+  const result = await axios.post(joinUrl(chainHost, '/api/gql/'), JSON.stringify({
+    query: `{
+        getAssetState(address: "${address}") {
+          state {
+            address
+            data {
+              typeUrl
+              value
+            }
+            issuer
+            owner
+            parent
+          }
+        }
+      }`
+  }), {
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    },
+    timeout: 60 * 1000
+  });
+  const state = get(result.data, 'data.getAssetState.state');
+  if (state && state.data.typeUrl === 'json') {
+    state.data.value = JSON.parse(state.data.value);
+  }
+  return state;
+}
+export function getAssetExpiration(asset) {
+  return last(get(asset, 'data.value.expirationDate', []));
+}
+
+/**
+ * 检查url是否 未添加到 store list 中
+ * @param {string} url - 需要检查的url
+ * @param {object[]} storeList - 后端的store list, 一般是 node.blockletRegistryList 或 blocklet.settings.storeList
+ * @returns {Object.freeze({
+ *  isNew: boolean;
+ *  decoded: string;
+ * })} - 返回判断是否是新的url和解码后的url
+ */
+export const isNewStoreUrl = (url, storeList) => {
+  if (typeof url === 'string') {
+    let decoded = decodeURIComponent(url?.trim());
+    const regex = /^https?:\/\//;
+    if (!regex.test(decoded)) {
+      decoded = `https://${decoded}`;
+    }
+    decoded = trimEnd(decoded, '/');
+
+    // validate
+    try {
+      new URL(decoded); // eslint-disable-line no-new
+    } catch {
+      throw new Error('Invalid Blocklet Store URL');
+    }
+    if (storeList?.some(item => [url, decoded].includes(item.url))) {
+      return {
+        isNew: false,
+        decoded
+      };
+    }
+    return {
+      isNew: true,
+      decoded
+    };
+  }
+  return {
+    isNew: false,
+    decoded: ''
+  };
+};
+export const isBlockletDev = blocklet => blocklet.mode === BLOCKLET_MODES.DEVELOPMENT;
+export const APP_PREFIX = window.env?.groupPathPrefix || '/';
+export const BlockletAdminRoles = [ROLES.ADMIN, ROLES.OWNER];
+export const toSlotDomain = domain => {
+  if (domain.endsWith(DEFAULT_IP_DOMAIN_SUFFIX)) {
+    const subDomain = domain.split('.').shift();
+    const matches = subDomain.match(IP);
+    if (matches) {
+      return domain.replace(matches[0].slice(1), SLOT_FOR_IP_DNS_SITE);
+    }
+  }
+  return domain;
+};
+export const getStoreList = ({
+  fromBlocklet,
+  nodeInfo,
+  blocklet
+}) => {
+  const teamDid = fromBlocklet ? blocklet?.meta?.did : nodeInfo?.did;
+  const storeList = fromBlocklet ? blocklet?.settings?.storeList || [] : nodeInfo?.blockletRegistryList || [];
+  return {
+    teamDid,
+    storeList
+  };
+};
+const isDidDomainOrIpEchoDomain = domain => {
+  if (!domain) {
+    return false;
+  }
+  return domain.endsWith(DEFAULT_DID_DOMAIN) || domain.endsWith(DEFAULT_IP_DOMAIN_SUFFIX);
+};
+export const sortDomains = domains => {
+  return (domains || []).sort((x, y) => {
+    if (isDidDomainOrIpEchoDomain(x.value) && isDidDomainOrIpEchoDomain(y.value)) {
+      return 0;
+    }
+    if (isDidDomainOrIpEchoDomain(x.value)) {
+      return 1;
+    }
+    if (isDidDomainOrIpEchoDomain(y.value)) {
+      return -1;
+    }
+    return 1;
+  });
+};
+export const formatMountPoint = value => normalizePathPrefix(urlPathFriendly(value));
+export const getRenewBlockletURL = ({
+  launcherUrl = '',
+  nftId = '',
+  locale = 'en'
+}) => joinUrl(launcherUrl, `/instances/${nftId}/renewal?locale=${locale}&return-url=${encodeURIComponent(window.location.href)}`);
+export const getSubscriptionURL = ({
+  launcherUrl = '',
+  nftId = '',
+  locale = 'en'
+}) => joinUrl(launcherUrl, `/instances/${nftId}/subscription?locale=${locale}&return-url=${encodeURIComponent(window.location.href)}`);
+export const nanoid = (length = 16) => [...Array(length)].map(() => Math.random().toString(36)[2]).join('');

package/es/util/mode.js

@@ -0,0 +1,4 @@
+/* eslint-disable import/prefer-default-export */
+
+// 当前模式是 内测模式 吗？ @see: https://developer.aliyun.com/article/572525
+export const enableDebug = localStorage.getItem('enableDebug') === 'true';

package/es/util/space-gateway.js

@@ -0,0 +1,51 @@
+/* eslint-disable import/prefer-default-export */
+import { isEmpty } from 'lodash';
+import { getSpaceNameByEndpoint } from './spaces';
+
+/**
+ * @description
+ * @export
+ * @param {{
+ *  nodeApi: import('@abtnode/client'),
+ *  blockletDid: string,
+ *  spaceGateways: import('../blocklet/storage/connected').SpaceGateway[],
+ * }} { nodeApi, blockletDid, spaceGateways }
+ * @return {Promise<import('../blocklet/storage/connected').SpaceGateway[]>}
+ */
+export async function updateSpaceGatewaysFromDIDSpaces({
+  blockletDid,
+  nodeApi,
+  spaceGateways
+}) {
+  let shouldUpdate = false;
+  const latestSpaceGateways = await Promise.all(spaceGateways.map(async x => {
+    let {
+      name
+    } = x;
+    const newName = await getSpaceNameByEndpoint(x.endpoint);
+    if (!isEmpty(newName) && newName !== name) {
+      name = newName;
+      shouldUpdate = true;
+    }
+    return {
+      ...x,
+      name
+    };
+  }));
+  if (shouldUpdate) {
+    await Promise.all(latestSpaceGateways.filter(x => x.did).map(x => {
+      return nodeApi.updateBlockletSpaceGateway({
+        input: {
+          did: blockletDid,
+          where: {
+            did: x.did
+          },
+          spaceGateway: {
+            ...x
+          }
+        }
+      });
+    }));
+  }
+  return latestSpaceGateways;
+}