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

package/dist/cjs/utils/polling.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var polling_exports = {};
+__export(polling_exports, {
+  waitUntilTrue: () => waitUntilTrue
+});
+module.exports = __toCommonJS(polling_exports);
+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;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  waitUntilTrue
+});

package/dist/cjs/utils/types.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  isServerAuthState: () => isServerAuthState
+});
+module.exports = __toCommonJS(types_exports);
+function isServerAuthState(obj) {
+  return "stage" in obj;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isServerAuthState
+});

package/dist/cjs/utils/url.js

@@ -0,0 +1,135 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var url_exports = {};
+__export(url_exports, {
+  constructUrl: () => constructUrl,
+  getParaConnectBaseUrl: () => getParaConnectBaseUrl,
+  getParaConnectDomain: () => getParaConnectDomain,
+  getPortalBaseURL: () => getPortalBaseURL,
+  getPortalDomain: () => getPortalDomain,
+  shortenUrl: () => shortenUrl
+});
+module.exports = __toCommonJS(url_exports);
+var import_transmissionUtils = require("../transmission/transmissionUtils.js");
+var import_types = require("../types/index.js");
+function getPortalDomain(env, isE2E) {
+  if (isE2E) {
+    return `localhost`;
+  }
+  switch (env) {
+    case import_types.Environment.DEV:
+      return "localhost";
+    case import_types.Environment.SANDBOX:
+      return "app.sandbox.usecapsule.com";
+    case import_types.Environment.BETA:
+      return "app.beta.usecapsule.com";
+    case import_types.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 === import_types.Environment.DEV) {
+    if (useLocalIp) {
+      return `http://127.0.0.1:3003`;
+    }
+    return `http://${domain}:3003`;
+  }
+  return `https://${domain}`;
+}
+function getParaConnectDomain(env) {
+  switch (env) {
+    case import_types.Environment.DEV:
+      return "localhost";
+    case import_types.Environment.SANDBOX:
+      return "connect.sandbox.getpara.com";
+    case import_types.Environment.BETA:
+      return "connect.beta.getpara.com";
+    case import_types.Environment.PROD:
+      return "connect.getpara.com";
+    default:
+      throw new Error(`env: ${env} not supported`);
+  }
+}
+function getParaConnectBaseUrl({ env }, useLocalIp) {
+  const domain = getParaConnectDomain(env);
+  if (env === import_types.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 (0, import_transmissionUtils.upload)(url, ctx.client);
+    return constructUrl({
+      base: getPortalBaseURL(ctx),
+      path: `/short/${compressedUrl}`
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  constructUrl,
+  getParaConnectBaseUrl,
+  getParaConnectDomain,
+  getPortalBaseURL,
+  getPortalDomain,
+  shortenUrl
+});

package/dist/cjs/utils/wallet.js

@@ -0,0 +1,159 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wallet_exports = {};
+__export(wallet_exports, {
+  WalletSchemeTypeMap: () => WalletSchemeTypeMap,
+  entityToWallet: () => entityToWallet,
+  getEquivalentTypes: () => getEquivalentTypes,
+  getSchemes: () => getSchemes,
+  getWalletTypes: () => getWalletTypes,
+  isPregenIdentifierMatch: () => isPregenIdentifierMatch,
+  isWalletSupported: () => isWalletSupported,
+  mergeCurrentWalletIds: () => mergeCurrentWalletIds,
+  migrateWallet: () => migrateWallet,
+  newUuid: () => newUuid,
+  supportedWalletTypesEq: () => supportedWalletTypesEq
+});
+module.exports = __toCommonJS(wallet_exports);
+var uuid = __toESM(require("uuid"));
+var import_phone = require("./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 (0, import_phone.formatPhoneNumber)(a) === (0, import_phone.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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WalletSchemeTypeMap,
+  entityToWallet,
+  getEquivalentTypes,
+  getSchemes,
+  getWalletTypes,
+  isPregenIdentifierMatch,
+  isWalletSupported,
+  mergeCurrentWalletIds,
+  migrateWallet,
+  newUuid,
+  supportedWalletTypesEq
+});