@edge-markets/connect-react-native 1.0.0

package/dist/index.mjs

@@ -0,0 +1,686 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  getEnvironmentConfig as getEnvironmentConfig2,
+  EDGE_ENVIRONMENTS,
+  ALL_EDGE_SCOPES as ALL_EDGE_SCOPES2,
+  SCOPE_DESCRIPTIONS,
+  formatScopesForEnvironment as formatScopesForEnvironment2,
+  EdgeError,
+  EdgeAuthenticationError,
+  EdgeConsentRequiredError,
+  EdgeTokenExchangeError,
+  EdgeApiError,
+  EdgeNetworkError,
+  EdgePopupBlockedError,
+  EdgeStateMismatchError,
+  isAuthenticationError,
+  isConsentRequiredError,
+  isApiError,
+  isNetworkError
+} from "@edge-markets/connect";
+
+// src/edge-link.ts
+import { Linking, Platform } from "react-native";
+import {
+  getEnvironmentConfig,
+  ALL_EDGE_SCOPES,
+  formatScopesForEnvironment
+} from "@edge-markets/connect";
+
+// src/pkce.ts
+function hasNativeCrypto() {
+  return typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function" && typeof globalThis.crypto.subtle !== "undefined";
+}
+async function sha256Fallback(message) {
+  try {
+    const ExpoCrypto = __require("expo-crypto");
+    const hash = await ExpoCrypto.digestStringAsync(
+      ExpoCrypto.CryptoDigestAlgorithm.SHA256,
+      message,
+      { encoding: ExpoCrypto.CryptoEncoding.BASE64 }
+    );
+    const binary = atob(hash);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  } catch {
+  }
+  try {
+    const { createHash } = __require("react-native-quick-crypto");
+    const hash = createHash("sha256").update(message).digest();
+    return hash.buffer;
+  } catch {
+  }
+  return pureJsSha256(message);
+}
+function pureJsSha256(message) {
+  const K = new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  const H = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  const bitLen = data.length * 8;
+  const padLen = (data.length + 8 >> 6) + 1 << 6;
+  const padded = new Uint8Array(padLen);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padLen - 4, bitLen, false);
+  const W = new Uint32Array(64);
+  for (let i = 0; i < padLen; i += 64) {
+    for (let j = 0; j < 16; j++) {
+      W[j] = view.getUint32(i + j * 4, false);
+    }
+    for (let j = 16; j < 64; j++) {
+      const s0 = rotr(W[j - 15], 7) ^ rotr(W[j - 15], 18) ^ W[j - 15] >>> 3;
+      const s1 = rotr(W[j - 2], 17) ^ rotr(W[j - 2], 19) ^ W[j - 2] >>> 10;
+      W[j] = W[j - 16] + s0 + W[j - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = H;
+    for (let j = 0; j < 64; j++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch + K[j] + W[j] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+    H[5] = H[5] + f >>> 0;
+    H[6] = H[6] + g >>> 0;
+    H[7] = H[7] + h >>> 0;
+  }
+  const result = new ArrayBuffer(32);
+  const resultView = new DataView(result);
+  for (let i = 0; i < 8; i++) {
+    resultView.setUint32(i * 4, H[i], false);
+  }
+  return result;
+  function rotr(x, n) {
+    return (x >>> n | x << 32 - n) >>> 0;
+  }
+}
+function getRandomBytes(byteLength) {
+  const array = new Uint8Array(byteLength);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(array);
+    return array;
+  }
+  try {
+    const ExpoRandom = __require("expo-random");
+    return ExpoRandom.getRandomBytes(byteLength);
+  } catch {
+  }
+  console.warn(
+    "[EdgeLink] Using Math.random fallback - NOT CRYPTOGRAPHICALLY SECURE!\nInstall react-native-get-random-values or expo-random for production."
+  );
+  for (let i = 0; i < byteLength; i++) {
+    array[i] = Math.floor(Math.random() * 256);
+  }
+  return array;
+}
+function generateRandomHex(byteLength) {
+  const bytes = getRandomBytes(byteLength);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256(plain) {
+  if (hasNativeCrypto()) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(plain);
+    return globalThis.crypto.subtle.digest("SHA-256", data);
+  }
+  return sha256Fallback(plain);
+}
+function base64UrlEncode(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  let base64;
+  if (typeof btoa === "function") {
+    base64 = btoa(binary);
+  } else {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    base64 = "";
+    let i = 0;
+    while (i < binary.length) {
+      const a = binary.charCodeAt(i++);
+      const b = binary.charCodeAt(i++);
+      const c = binary.charCodeAt(i++);
+      base64 += chars[a >> 2] + chars[(a & 3) << 4 | b >> 4] + (isNaN(b) ? "=" : chars[(b & 15) << 2 | c >> 6]) + (isNaN(c) ? "=" : chars[c & 63]);
+    }
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function generatePKCE() {
+  const verifier = generateRandomHex(64);
+  const hash = await sha256(verifier);
+  const challenge = base64UrlEncode(hash);
+  return { verifier, challenge };
+}
+function generateState() {
+  return generateRandomHex(32);
+}
+function isSecureCryptoAvailable() {
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    return true;
+  }
+  try {
+    __require("expo-random");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/edge-link.ts
+async function openInAppBrowser(url, useExternal = false) {
+  if (useExternal) {
+    await Linking.openURL(url);
+    return;
+  }
+  try {
+    const InAppBrowser = __require("react-native-inappbrowser-reborn").default;
+    if (await InAppBrowser.isAvailable()) {
+      await InAppBrowser.openAuth(url, "", {
+        // iOS options
+        dismissButtonStyle: "cancel",
+        preferredBarTintColor: "#1a1a2e",
+        preferredControlTintColor: "#00d4aa",
+        readerMode: false,
+        animated: true,
+        modalEnabled: true,
+        enableBarCollapsing: false,
+        // Android options
+        showTitle: true,
+        toolbarColor: "#1a1a2e",
+        secondaryToolbarColor: "#16213e",
+        navigationBarColor: "#1a1a2e",
+        navigationBarDividerColor: "#16213e",
+        enableUrlBarHiding: true,
+        enableDefaultShare: false,
+        forceCloseOnRedirection: false,
+        animations: {
+          startEnter: "slide_in_right",
+          startExit: "slide_out_left",
+          endEnter: "slide_in_left",
+          endExit: "slide_out_right"
+        }
+      });
+      return;
+    }
+  } catch {
+  }
+  try {
+    const WebBrowser = __require("expo-web-browser");
+    await WebBrowser.openAuthSessionAsync(url, "");
+    return;
+  } catch {
+  }
+  console.warn("[EdgeLink] No in-app browser library found. Using external browser.");
+  await Linking.openURL(url);
+}
+async function closeInAppBrowser() {
+  try {
+    const InAppBrowser = __require("react-native-inappbrowser-reborn").default;
+    InAppBrowser.close();
+  } catch {
+  }
+  try {
+    const WebBrowser = __require("expo-web-browser");
+    WebBrowser.dismissBrowser();
+  } catch {
+  }
+}
+var EdgeLink = class {
+  constructor(config) {
+    this.pkce = null;
+    this.state = null;
+    this.linkListener = null;
+    this.isOpen = false;
+    this.isDestroyed = false;
+    if (!config.clientId) {
+      throw new Error("EdgeLink: clientId is required");
+    }
+    if (!config.environment) {
+      throw new Error("EdgeLink: environment is required");
+    }
+    if (!config.redirectUri) {
+      throw new Error("EdgeLink: redirectUri is required for React Native");
+    }
+    if (!config.onSuccess) {
+      throw new Error("EdgeLink: onSuccess callback is required");
+    }
+    this.config = config;
+  }
+  /**
+   * Opens the EdgeLink authentication flow.
+   *
+   * This launches an in-app browser with the EdgeBoost login/consent page.
+   * When complete, the browser redirects to your redirectUri and the
+   * onSuccess/onExit callback is called.
+   */
+  async open() {
+    if (this.isDestroyed) {
+      throw new Error("EdgeLink: Cannot open - instance has been destroyed");
+    }
+    if (this.isOpen) {
+      console.warn("[EdgeLink] Already open");
+      return;
+    }
+    this.emitEvent("OPEN");
+    this.isOpen = true;
+    try {
+      this.pkce = await generatePKCE();
+      this.state = generateState();
+      this.setupLinkListener();
+      const url = this.buildLinkUrl();
+      this.emitEvent("HANDOFF", { url });
+      await openInAppBrowser(url, this.config.useExternalBrowser);
+    } catch (error) {
+      this.cleanup();
+      this.emitEvent("ERROR", { error });
+      this.config.onExit?.({
+        reason: "error",
+        error: {
+          code: "open_failed",
+          message: error instanceof Error ? error.message : "Failed to open browser"
+        }
+      });
+    }
+  }
+  /**
+   * Manually handles a deep link URL.
+   *
+   * Use this if you're handling deep links yourself instead of relying
+   * on the automatic listener.
+   *
+   * @param url - The deep link URL received
+   * @returns true if the URL was handled, false otherwise
+   */
+  handleDeepLink(url) {
+    if (!this.isOpen || !url.startsWith(this.config.redirectUri)) {
+      return false;
+    }
+    this.processCallback(url);
+    return true;
+  }
+  /**
+   * Closes the EdgeLink flow.
+   */
+  async close() {
+    if (!this.isOpen) return;
+    await closeInAppBrowser();
+    this.cleanup();
+    this.emitEvent("CLOSE", { reason: "programmatic" });
+    this.config.onExit?.({
+      reason: "user_closed"
+    });
+  }
+  /**
+   * Destroys the EdgeLink instance.
+   */
+  destroy() {
+    this.isDestroyed = true;
+    this.cleanup();
+  }
+  // ===========================================================================
+  // PRIVATE METHODS
+  // ===========================================================================
+  buildLinkUrl() {
+    const envConfig = getEnvironmentConfig(this.config.environment);
+    const baseUrl = this.config.linkUrl || `${envConfig.userClientUrl}/oauth/link`;
+    const url = new URL(baseUrl);
+    const scopes = this.config.scopes || ALL_EDGE_SCOPES;
+    url.searchParams.set("client_id", this.config.clientId);
+    url.searchParams.set("state", this.state);
+    url.searchParams.set("code_challenge", this.pkce.challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("redirect_uri", this.config.redirectUri);
+    const formattedScopes = formatScopesForEnvironment(scopes, this.config.environment);
+    url.searchParams.set("scope", formattedScopes.join(" "));
+    url.searchParams.set("platform", Platform.OS);
+    url.searchParams.set("flow", "redirect");
+    return url.toString();
+  }
+  setupLinkListener() {
+    this.removeLinkListener();
+    this.linkListener = Linking.addEventListener("url", ({ url }) => {
+      if (url.startsWith(this.config.redirectUri)) {
+        this.processCallback(url);
+      }
+    });
+    Linking.getInitialURL().then((url) => {
+      if (url && url.startsWith(this.config.redirectUri) && this.isOpen) {
+        this.processCallback(url);
+      }
+    });
+  }
+  removeLinkListener() {
+    if (this.linkListener) {
+      this.linkListener.remove();
+      this.linkListener = null;
+    }
+  }
+  processCallback(url) {
+    this.emitEvent("REDIRECT", { url });
+    try {
+      const parsed = new URL(url);
+      const code = parsed.searchParams.get("code");
+      const returnedState = parsed.searchParams.get("state");
+      const error = parsed.searchParams.get("error");
+      const errorDescription = parsed.searchParams.get("error_description");
+      closeInAppBrowser();
+      if (error) {
+        this.cleanup();
+        this.config.onExit?.({
+          reason: "error",
+          error: {
+            code: error,
+            message: errorDescription || "Authorization error"
+          }
+        });
+        return;
+      }
+      if (returnedState !== this.state) {
+        this.cleanup();
+        this.config.onExit?.({
+          reason: "error",
+          error: {
+            code: "state_mismatch",
+            message: "Security error: state parameter mismatch. Please try again."
+          }
+        });
+        return;
+      }
+      if (!code) {
+        this.cleanup();
+        this.config.onExit?.({
+          reason: "error",
+          error: {
+            code: "no_code",
+            message: "No authorization code received"
+          }
+        });
+        return;
+      }
+      const codeVerifier = this.pkce.verifier;
+      this.cleanup();
+      this.emitEvent("SUCCESS");
+      this.config.onSuccess({
+        code,
+        codeVerifier,
+        state: returnedState
+      });
+    } catch (error) {
+      this.cleanup();
+      this.config.onExit?.({
+        reason: "error",
+        error: {
+          code: "parse_error",
+          message: error instanceof Error ? error.message : "Failed to parse callback URL"
+        }
+      });
+    }
+  }
+  cleanup() {
+    this.removeLinkListener();
+    this.pkce = null;
+    this.state = null;
+    this.isOpen = false;
+  }
+  emitEvent(eventName, metadata) {
+    this.config.onEvent?.({
+      eventName,
+      timestamp: Date.now(),
+      metadata
+    });
+  }
+};
+
+// src/hooks.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useEdgeLink(config) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [isSuccess, setIsSuccess] = useState(false);
+  const [isError, setIsError] = useState(false);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const linkRef = useRef(null);
+  useEffect(() => {
+    const linkConfig = {
+      clientId: config.clientId,
+      environment: config.environment,
+      redirectUri: config.redirectUri,
+      scopes: config.scopes,
+      linkUrl: config.linkUrl,
+      useExternalBrowser: config.useExternalBrowser,
+      onSuccess: (successResult) => {
+        setIsOpen(false);
+        setIsSuccess(true);
+        setIsError(false);
+        setResult(successResult);
+        setError(null);
+      },
+      onExit: (metadata) => {
+        setIsOpen(false);
+        if (metadata.error) {
+          setIsError(true);
+          setError(metadata.error);
+        }
+      }
+    };
+    linkRef.current = new EdgeLink(linkConfig);
+    return () => {
+      linkRef.current?.destroy();
+      linkRef.current = null;
+    };
+  }, [
+    config.clientId,
+    config.environment,
+    config.redirectUri,
+    config.scopes,
+    config.linkUrl,
+    config.useExternalBrowser
+  ]);
+  const open = useCallback(async () => {
+    if (!linkRef.current) return;
+    setIsOpen(true);
+    setIsSuccess(false);
+    setIsError(false);
+    setError(null);
+    await linkRef.current.open();
+  }, []);
+  const close = useCallback(async () => {
+    if (!linkRef.current) return;
+    await linkRef.current.close();
+    setIsOpen(false);
+  }, []);
+  const reset = useCallback(() => {
+    setIsSuccess(false);
+    setIsError(false);
+    setResult(null);
+    setError(null);
+  }, []);
+  return {
+    open,
+    close,
+    isOpen,
+    isSuccess,
+    isError,
+    result,
+    error,
+    reset
+  };
+}
+function useEdgeLinkHandler(config) {
+  const handleUrl = useCallback(
+    (url) => {
+      if (!url.startsWith(config.redirectUri)) {
+        return false;
+      }
+      try {
+        const parsed = new URL(url);
+        const code = parsed.searchParams.get("code");
+        const state = parsed.searchParams.get("state");
+        const error = parsed.searchParams.get("error");
+        const errorDescription = parsed.searchParams.get("error_description");
+        const codeVerifier = parsed.searchParams.get("code_verifier");
+        if (error) {
+          config.onError?.({
+            code: error,
+            message: errorDescription || "Authorization error"
+          });
+          return true;
+        }
+        if (code && state) {
+          config.onSuccess({
+            code,
+            codeVerifier: codeVerifier || "",
+            // Might be empty if not passed in URL
+            state
+          });
+          return true;
+        }
+        config.onError?.({
+          code: "invalid_callback",
+          message: "Missing code or state in callback URL"
+        });
+        return true;
+      } catch (e) {
+        config.onError?.({
+          code: "parse_error",
+          message: "Failed to parse callback URL"
+        });
+        return true;
+      }
+    },
+    [config]
+  );
+  return { handleUrl };
+}
+function useEdgeLinkEvents(onEvent, deps = []) {
+  useEffect(() => {
+  }, [onEvent, ...deps]);
+}
+export {
+  ALL_EDGE_SCOPES2 as ALL_EDGE_SCOPES,
+  EDGE_ENVIRONMENTS,
+  EdgeApiError,
+  EdgeAuthenticationError,
+  EdgeConsentRequiredError,
+  EdgeError,
+  EdgeLink,
+  EdgeNetworkError,
+  EdgePopupBlockedError,
+  EdgeStateMismatchError,
+  EdgeTokenExchangeError,
+  SCOPE_DESCRIPTIONS,
+  formatScopesForEnvironment2 as formatScopesForEnvironment,
+  generatePKCE,
+  generateState,
+  getEnvironmentConfig2 as getEnvironmentConfig,
+  isApiError,
+  isAuthenticationError,
+  isConsentRequiredError,
+  isNetworkError,
+  isSecureCryptoAvailable,
+  useEdgeLink,
+  useEdgeLinkEvents,
+  useEdgeLinkHandler
+};