@nylas/react 2.1.0 → 2.2.1

package/dist/connect.d.ts

@@ -0,0 +1 @@
+export * from './lib/connect'

package/dist/elements.d.ts

@@ -0,0 +1 @@
+export * from './lib/elements'

package/dist/es/connect.js

@@ -0,0 +1,279 @@
+import { useRef as m, useEffect as f, useState as D, useCallback as i } from "react";
+import { NylasConnect as O } from "@nylas/connect";
+import { BrowserTokenStorage as z, ConfigError as G, MemoryTokenStorage as K, NetworkError as V, NylasConnect as B, NylasConnectError as W, OAuthError as X, PopupError as j, TokenError as q, isAuthCallback as F, logger as J, parseAuthCallback as Q } from "@nylas/connect";
+function M(E) {
+  const {
+    autoRefreshInterval: d,
+    initialLoadingState: y = !0,
+    retryAttempts: u = 0,
+    enableAutoRecovery: b = !1,
+    ...P
+  } = E, h = m(null);
+  h.current || (h.current = new O(P));
+  const n = h.current, w = m({
+    isProcessing: !1,
+    processedUrl: null,
+    hasProcessed: !1
+  });
+  f(() => {
+    var r;
+    const s = ((r = globalThis.window) == null ? void 0 : r.location.href) || "", t = w.current;
+    !(s.includes("code=") && s.includes("state=")) && t.hasProcessed && (t.hasProcessed = !1, t.processedUrl = null);
+  }), f(() => n.isAutoCallbackEnabled() ? ((async () => {
+    var o, a, g;
+    const t = ((o = globalThis.window) == null ? void 0 : o.location.href) || "", e = w.current;
+    if (!(e.isProcessing || e.processedUrl === t || e.hasProcessed || !(t.includes("code=") && t.includes("state=")))) {
+      try {
+        if (await n.getSession()) {
+          e.hasProcessed = !0, e.processedUrl = t;
+          return;
+        }
+      } catch {
+      }
+      e.isProcessing = !0, e.processedUrl = t;
+      try {
+        if (await n.callback(), e.hasProcessed = !0, (g = (a = globalThis.window) == null ? void 0 : a.history) != null && g.replaceState) {
+          const c = new URL(globalThis.window.location.href), U = ["code", "state", "error", "error_description"];
+          let C = !1;
+          U.forEach((S) => {
+            c.searchParams.has(S) && (c.searchParams.delete(S), C = !0);
+          }), C && globalThis.window.history.replaceState(
+            globalThis.window.history.state,
+            document.title,
+            c.toString()
+          );
+        }
+      } catch (c) {
+        console.log("callback error", c), e.isProcessing = !1, e.processedUrl = null;
+      } finally {
+        e.isProcessing = !1;
+      }
+    }
+  })(), () => {
+    const t = w.current;
+    t.isProcessing || (t.processedUrl = null, t.hasProcessed = !1);
+  }) : void 0, [n]);
+  const [L, l] = D({
+    isConnected: !1,
+    grant: null,
+    isLoading: y,
+    error: null
+  });
+  f(() => {
+    let s = !0;
+    return (async () => {
+      try {
+        const e = await n.getSession(), r = await n.isConnected();
+        s && l((o) => ({
+          ...o,
+          isConnected: r,
+          grant: (e == null ? void 0 : e.grantInfo) || null,
+          isLoading: !1,
+          error: null
+        }));
+      } catch (e) {
+        s && l((r) => ({
+          ...r,
+          isConnected: !1,
+          grant: null,
+          isLoading: !1,
+          error: e
+        }));
+      }
+    })(), () => {
+      s = !1;
+    };
+  }, [n]), f(() => {
+    if (!d || d <= 0)
+      return;
+    const s = setInterval(async () => {
+      try {
+        const t = await n.getSession(), e = await n.isConnected();
+        l((r) => ({
+          ...r,
+          isConnected: e,
+          grant: (t == null ? void 0 : t.grantInfo) || null,
+          error: null
+        }));
+      } catch (t) {
+        b ? console.debug(
+          "Auto-refresh failed, will retry next interval:",
+          t
+        ) : l((e) => ({
+          ...e,
+          error: t
+        }));
+      }
+    }, d);
+    return () => clearInterval(s);
+  }, [n, d, b]), f(() => {
+    const s = (e, r, o) => {
+      l((a) => {
+        switch (e) {
+          case "AUTH_STARTED":
+            return {
+              ...a,
+              isLoading: !0,
+              error: null
+            };
+          case "SIGNED_IN":
+          case "SESSION_RESTORED":
+            return {
+              ...a,
+              isConnected: !0,
+              grant: (r == null ? void 0 : r.grantInfo) || null,
+              isLoading: !1,
+              error: null
+            };
+          case "SIGNED_OUT":
+            return {
+              ...a,
+              isConnected: !1,
+              grant: null,
+              isLoading: !1,
+              error: null
+            };
+          case "AUTH_ERROR":
+          case "NETWORK_ERROR":
+          case "TOKEN_VALIDATION_ERROR":
+            return {
+              ...a,
+              isLoading: !1,
+              error: (o == null ? void 0 : o.error) || new Error("Authentication error")
+            };
+          case "AUTH_CANCELLED":
+            return {
+              ...a,
+              isLoading: !1,
+              error: null
+            };
+          case "SESSION_EXPIRED":
+          case "SESSION_INVALID":
+            return {
+              ...a,
+              isConnected: !1,
+              grant: null,
+              isLoading: !1,
+              error: null
+            };
+          default:
+            return a;
+        }
+      });
+    };
+    return n.onAuthStateChange(
+      s
+    );
+  }, [n]);
+  const A = i(
+    async (s = {}) => {
+      l((r) => ({ ...r, isLoading: !0, error: null }));
+      let t;
+      const e = u + 1;
+      for (let r = 1; r <= e; r++)
+        try {
+          return await n.connect(s);
+        } catch (o) {
+          if (t = o, r < e) {
+            const a = Math.min(1e3 * Math.pow(2, r - 1), 5e3);
+            await new Promise((g) => setTimeout(g, a));
+          }
+        }
+      throw t;
+    },
+    [n, u]
+  ), p = i(
+    async (s) => {
+      l((r) => ({ ...r, isLoading: !0, error: null }));
+      let t;
+      const e = u + 1;
+      for (let r = 1; r <= e; r++)
+        try {
+          await n.logout(s);
+          return;
+        } catch (o) {
+          if (t = o, r < e) {
+            const a = Math.min(1e3 * Math.pow(2, r - 1), 3e3);
+            await new Promise((g) => setTimeout(g, a));
+          }
+        }
+      throw l((r) => ({
+        ...r,
+        isLoading: !1,
+        error: t
+      })), t;
+    },
+    [n, u]
+  ), T = i(async () => {
+    l((e) => ({ ...e, isLoading: !0, error: null }));
+    let s;
+    const t = u + 1;
+    for (let e = 1; e <= t; e++)
+      try {
+        const r = await n.getSession(), o = await n.isConnected();
+        l((a) => ({
+          ...a,
+          isConnected: o,
+          grant: (r == null ? void 0 : r.grantInfo) || null,
+          isLoading: !1,
+          error: null
+        }));
+        return;
+      } catch (r) {
+        if (s = r, e < t) {
+          const o = Math.min(1e3 * Math.pow(2, e - 1), 3e3);
+          await new Promise((a) => setTimeout(a, o));
+        }
+      }
+    throw l((e) => ({
+      ...e,
+      isConnected: !1,
+      grant: null,
+      isLoading: !1,
+      error: s
+    })), s;
+  }, [n, u]), k = i(
+    (s) => n.onAuthStateChange(s),
+    [n]
+  ), R = i(() => {
+    n.enableDebug();
+  }, [n]), I = i(() => {
+    n.disableDebug();
+  }, [n]), N = i(
+    (s) => {
+      n.setLogLevel(s);
+    },
+    [n]
+  );
+  return {
+    // State
+    ...L,
+    // Actions
+    connect: A,
+    logout: p,
+    refreshSession: T,
+    subscribe: k,
+    // Logger controls
+    enableDebug: R,
+    disableDebug: I,
+    setLogLevel: N,
+    // Direct access
+    authClient: n,
+    logger: n.logger
+  };
+}
+export {
+  z as BrowserTokenStorage,
+  G as ConfigError,
+  K as MemoryTokenStorage,
+  V as NetworkError,
+  B as NylasConnect,
+  W as NylasConnectError,
+  X as OAuthError,
+  j as PopupError,
+  q as TokenError,
+  F as isAuthCallback,
+  J as logger,
+  Q as parseAuthCallback,
+  M as useNylasConnect
+};