@getpara/core-sdk 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/esm/utils/phone.js

@@ -0,0 +1,28 @@
+import "../chunk-7B52C2XE.js";
+import parsePhoneNumberFromString from "libphonenumber-js";
+function formatPhoneNumber(phone, countryCode, { forDisplay = false } = {}) {
+  phone = phone.toString();
+  countryCode = countryCode == null ? void 0 : countryCode.toString();
+  let sanitizedNumber, parsedNumber;
+  if (!!countryCode) {
+    sanitizedNumber = phone.replace(/\D/g, "");
+    if (/^\+\d+$/.test(countryCode)) {
+      countryCode = countryCode.slice(1);
+    }
+    parsedNumber = parsePhoneNumberFromString(sanitizedNumber, { defaultCallingCode: countryCode });
+  } else {
+    sanitizedNumber = `+${phone.replace(/\D/g, "")}`;
+    parsedNumber = parsePhoneNumberFromString(sanitizedNumber);
+  }
+  if (parsedNumber == null ? void 0 : parsedNumber.isValid()) {
+    return forDisplay ? parsedNumber.formatInternational() : parsedNumber.formatInternational().replace(/[^\d+]/g, "");
+  }
+  return null;
+}
+function displayPhoneNumber(phone, countryCode) {
+  return formatPhoneNumber(phone, countryCode, { forDisplay: true });
+}
+export {
+  displayPhoneNumber,
+  formatPhoneNumber
+};

package/dist/esm/utils/polling.js

@@ -0,0 +1,18 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+function waitUntilTrue(condition, timeoutMs, intervalMs) {
+  return __async(this, null, function* () {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (yield condition()) {
+        return true;
+      }
+      yield new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return false;
+  });
+}
+export {
+  waitUntilTrue
+};

package/dist/esm/utils/types.js

@@ -0,0 +1,7 @@
+import "../chunk-7B52C2XE.js";
+function isServerAuthState(obj) {
+  return "stage" in obj;
+}
+export {
+  isServerAuthState
+};

package/dist/esm/utils/url.js

@@ -0,0 +1,90 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import { upload } from "../transmission/transmissionUtils.js";
+import { Environment } from "../types/index.js";
+function getPortalDomain(env, isE2E) {
+  if (isE2E) {
+    return `localhost`;
+  }
+  switch (env) {
+    case Environment.DEV:
+      return "localhost";
+    case Environment.SANDBOX:
+      return "app.sandbox.usecapsule.com";
+    case Environment.BETA:
+      return "app.beta.usecapsule.com";
+    case Environment.PROD:
+      return "app.usecapsule.com";
+    default:
+      throw new Error(`env: ${env} not supported`);
+  }
+}
+function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm) {
+  if (isE2E) {
+    if (isForWasm) {
+      return `https://app.sandbox.usecapsule.com`;
+    }
+    return `http://localhost:3003`;
+  }
+  const domain = getPortalDomain(env);
+  if (env === Environment.DEV) {
+    if (useLocalIp) {
+      return `http://127.0.0.1:3003`;
+    }
+    return `http://${domain}:3003`;
+  }
+  return `https://${domain}`;
+}
+function getParaConnectDomain(env) {
+  switch (env) {
+    case Environment.DEV:
+      return "localhost";
+    case Environment.SANDBOX:
+      return "connect.sandbox.getpara.com";
+    case Environment.BETA:
+      return "connect.beta.getpara.com";
+    case Environment.PROD:
+      return "connect.getpara.com";
+    default:
+      throw new Error(`env: ${env} not supported`);
+  }
+}
+function getParaConnectBaseUrl({ env }, useLocalIp) {
+  const domain = getParaConnectDomain(env);
+  if (env === Environment.DEV) {
+    if (useLocalIp) {
+      return `http://127.0.0.1:3008`;
+    }
+    return `http://${domain}:3008`;
+  }
+  return `https://${domain}`;
+}
+function constructUrl({
+  base,
+  path,
+  params = {}
+}) {
+  const url = new URL(path, base);
+  Object.entries(params).forEach(([key, value]) => {
+    if (!!value && value !== "undefined" && value !== "null") url.searchParams.set(key, value.toString());
+  });
+  return url.toString();
+}
+function shortenUrl(ctx, url) {
+  return __async(this, null, function* () {
+    const compressedUrl = yield upload(url, ctx.client);
+    return constructUrl({
+      base: getPortalBaseURL(ctx),
+      path: `/short/${compressedUrl}`
+    });
+  });
+}
+export {
+  constructUrl,
+  getParaConnectBaseUrl,
+  getParaConnectDomain,
+  getPortalBaseURL,
+  getPortalDomain,
+  shortenUrl
+};

package/dist/esm/utils/wallet.js

@@ -0,0 +1,103 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import * as uuid from "uuid";
+import { formatPhoneNumber } from "./phone.js";
+const WalletSchemeTypeMap = {
+  DKLS: {
+    EVM: true,
+    COSMOS: true
+  },
+  CGGMP: {
+    EVM: true,
+    COSMOS: true
+  },
+  ED25519: {
+    SOLANA: true
+  }
+};
+function isPregenIdentifierMatch(a, b, type) {
+  if (!a || !b) {
+    return false;
+  }
+  switch (type) {
+    case "EMAIL":
+      return a.toLowerCase() === b.toLowerCase();
+    case "PHONE":
+      return formatPhoneNumber(a) === formatPhoneNumber(b);
+    case "CUSTOM_ID":
+      return a === b;
+    default:
+      return a.replace(/^@/g, "").toLowerCase() === b.replace(/^@/g, "").toLowerCase();
+  }
+}
+function isWalletSupported(types, wallet) {
+  return types.some((walletType) => {
+    var _a;
+    return !!((_a = WalletSchemeTypeMap[wallet == null ? void 0 : wallet.scheme]) == null ? void 0 : _a[walletType]);
+  });
+}
+function getSchemes(types) {
+  return Object.keys(WalletSchemeTypeMap).filter((scheme) => {
+    if (scheme === "CGGMP") {
+      return false;
+    }
+    return (Array.isArray(types) ? types : Object.keys(types)).some((type) => WalletSchemeTypeMap[scheme][type]);
+  });
+}
+function getWalletTypes(schemes) {
+  return [
+    ...new Set(
+      schemes.reduce((acc, scheme) => {
+        return [...acc, ...Object.keys(WalletSchemeTypeMap[scheme]).filter((type) => WalletSchemeTypeMap[scheme][type])];
+      }, [])
+    )
+  ];
+}
+function getEquivalentTypes(types) {
+  return getWalletTypes(getSchemes(Array.isArray(types) ? types : [types]));
+}
+function entityToWallet(w) {
+  return __spreadProps(__spreadValues({}, w), {
+    scheme: w.scheme,
+    type: w.type,
+    pregenIdentifierType: w.pregenIdentifierType
+  });
+}
+function migrateWallet(obj) {
+  if (["USER", "PREGEN"].includes(obj.type)) {
+    obj.isPregen = obj.type === "PREGEN";
+    obj.type = obj.scheme === "ED25519" ? "SOLANA" : "EVM";
+  }
+  if (!!obj.scheme && !obj.type) {
+    obj.type = obj.scheme === "ED25519" ? "SOLANA" : "EVM";
+  }
+  return obj;
+}
+function supportedWalletTypesEq(a, b) {
+  return a.length === b.length && a.every(({ type, optional }, index) => b[index].type === type && b[index].optional === optional);
+}
+function mergeCurrentWalletIds(original, additional) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(original), ...Object.keys(additional)])].reduce((acc, key) => {
+    return __spreadProps(__spreadValues({}, acc), {
+      [key]: [.../* @__PURE__ */ new Set([...original[key] || [], ...additional[key] || []])]
+    });
+  }, {});
+}
+function newUuid() {
+  return uuid.v4();
+}
+export {
+  WalletSchemeTypeMap,
+  entityToWallet,
+  getEquivalentTypes,
+  getSchemes,
+  getWalletTypes,
+  isPregenIdentifierMatch,
+  isWalletSupported,
+  mergeCurrentWalletIds,
+  migrateWallet,
+  newUuid,
+  supportedWalletTypesEq
+};