@stackframe/stack 2.3.5 → 2.3.7

package/dist/esm/components-page/forgot-password.js

@@ -0,0 +1,35 @@
+"use client";
+"use client";
+
+// src/components-page/forgot-password.tsx
+import ForgotPasswordElement from "../components/forgot-password";
+import CardFrame from "../components/card-frame";
+import { useUser, useStackApp } from "..";
+import RedirectMessageCard from "../components/redirect-message-card";
+import { useState } from "react";
+import { Link, Text } from "../components-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ForgotPassword({ fullPage = false }) {
+  const stackApp = useStackApp();
+  const user = useUser();
+  const [sent, setSent] = useState(false);
+  if (user) {
+    return /* @__PURE__ */ jsx(RedirectMessageCard, { type: "signedIn", fullPage });
+  }
+  if (sent) {
+    return /* @__PURE__ */ jsx(RedirectMessageCard, { type: "emailSent", fullPage });
+  }
+  return /* @__PURE__ */ jsxs(CardFrame, { fullPage, children: [
+    /* @__PURE__ */ jsxs("div", { style: { textAlign: "center", marginBottom: "1.5rem" }, children: [
+      /* @__PURE__ */ jsx(Text, { size: "xl", as: "h2", children: "Reset Your Password" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Don't need to reset? ",
+        /* @__PURE__ */ jsx(Link, { href: stackApp.urls["signUp"], children: "Sign In" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(ForgotPasswordElement, { onSent: () => setSent(true) })
+  ] });
+}
+export {
+  ForgotPassword as default
+};

package/dist/esm/components-page/magic-link-callback.js

@@ -0,0 +1,43 @@
+"use client";
+"use client";
+
+// src/components-page/magic-link-callback.tsx
+import { use } from "react";
+import { useStackApp, useUser } from "..";
+import MessageCard from "../components/message-card";
+import RedirectMessageCard from "../components/redirect-message-card";
+import { KnownErrors } from "@stackframe/stack-shared";
+import { neverResolve } from "@stackframe/stack-shared/dist/utils/promises";
+import { jsx } from "react/jsx-runtime";
+function MagicLinkCallback({
+  searchParams: {
+    code = ""
+  } = {},
+  fullPage = false
+}) {
+  const stackApp = useStackApp();
+  const user = useUser();
+  if (user) {
+    return /* @__PURE__ */ jsx(RedirectMessageCard, { type: "signedIn", fullPage });
+  }
+  const invalidJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Invalid Magic Link", fullPage, children: /* @__PURE__ */ jsx("p", { children: "Please check if you have the correct link. If you continue to have issues, please contact support." }) });
+  const expiredJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Expired Magic Link", fullPage, children: /* @__PURE__ */ jsx("p", { children: "Your magic link has expired. Please request a new magic link if you need to sign-in." }) });
+  const allredyUsedJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Magic Link Already Used", fullPage, children: /* @__PURE__ */ jsx("p", { children: "The magic link has already been used. The link can only be used once. Please request a new magic link if you need to sign-in again." }) });
+  if (!code) {
+    return invalidJsx;
+  }
+  const error = use(stackApp.signInWithMagicLink(code));
+  if (error instanceof KnownErrors.MagicLinkCodeNotFound) {
+    return invalidJsx;
+  } else if (error instanceof KnownErrors.MagicLinkCodeExpired) {
+    return expiredJsx;
+  } else if (error instanceof KnownErrors.MagicLinkCodeAlreadyUsed) {
+    return allredyUsedJsx;
+  } else if (error) {
+    throw error;
+  }
+  use(neverResolve());
+}
+export {
+  MagicLinkCallback as default
+};

package/dist/esm/components-page/oauth-callback.js

@@ -0,0 +1,23 @@
+"use client";
+"use client";
+
+// src/components-page/oauth-callback.tsx
+import { useRef, useEffect } from "react";
+import { useStackApp } from "..";
+import { runAsynchronously } from "@stackframe/stack-shared/dist/utils/promises";
+import MessageCard from "../components/message-card";
+import { jsx } from "react/jsx-runtime";
+function OAuthCallback() {
+  const app = useStackApp();
+  const called = useRef(false);
+  useEffect(() => runAsynchronously(async () => {
+    if (called.current)
+      return;
+    called.current = true;
+    await app.callOAuthCallback();
+  }), []);
+  return /* @__PURE__ */ jsx(MessageCard, { title: "Redirecting...", fullPage: true });
+}
+export {
+  OAuthCallback as default
+};

package/dist/esm/components-page/password-reset.js

@@ -0,0 +1,42 @@
+"use client";
+"use client";
+
+// src/components-page/password-reset.tsx
+import MessageCard from "../components/message-card";
+import { useStackApp } from "..";
+import { use } from "react";
+import PasswordResetInner from "../components/password-reset-inner";
+import { cacheFunction } from "@stackframe/stack-shared/dist/utils/caches";
+import { Text } from "../components-core";
+import { KnownErrors } from "@stackframe/stack-shared";
+import { jsx } from "react/jsx-runtime";
+var cachedVerifyPasswordResetCode = cacheFunction(async (stackApp, code) => {
+  return await stackApp.verifyPasswordResetCode(code);
+});
+function PasswordReset({
+  searchParams,
+  fullPage = false
+}) {
+  const stackApp = useStackApp();
+  const invalidJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Invalid Password Reset Link", fullPage, children: /* @__PURE__ */ jsx(Text, { children: "Please double check if you have the correct password reset link." }) });
+  const expiredJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Expired Password Reset Link", fullPage, children: /* @__PURE__ */ jsx(Text, { children: "Your password reset link has expired. Please request a new password reset link from the login page." }) });
+  const usedJsx = /* @__PURE__ */ jsx(MessageCard, { title: "Used Password Reset Link", fullPage, children: /* @__PURE__ */ jsx(Text, { children: "This password reset link has already been used. If you need to reset your password again, please request a new password reset link from the login page." }) });
+  const code = searchParams?.code;
+  if (!code) {
+    return invalidJsx;
+  }
+  const error = use(cachedVerifyPasswordResetCode(stackApp, code));
+  if (error instanceof KnownErrors.PasswordResetCodeNotFound) {
+    return invalidJsx;
+  } else if (error instanceof KnownErrors.PasswordResetCodeExpired) {
+    return expiredJsx;
+  } else if (error instanceof KnownErrors.PasswordResetCodeAlreadyUsed) {
+    return usedJsx;
+  } else if (error) {
+    throw error;
+  }
+  return /* @__PURE__ */ jsx(PasswordResetInner, { code, fullPage });
+}
+export {
+  PasswordReset as default
+};

package/dist/esm/components-page/sign-in.js

@@ -0,0 +1,12 @@
+"use client";
+"use client";
+
+// src/components-page/sign-in.tsx
+import AuthPage from "./auth-page";
+import { jsx } from "react/jsx-runtime";
+function SignIn({ fullPage = false }) {
+  return /* @__PURE__ */ jsx(AuthPage, { fullPage, type: "sign-in" });
+}
+export {
+  SignIn as default
+};

package/dist/esm/components-page/sign-out.js

@@ -0,0 +1,18 @@
+"use client";
+"use client";
+
+// src/components-page/sign-out.tsx
+import { use } from "react";
+import { useUser } from "..";
+import GoHomeMessageCard from "../components/redirect-message-card";
+import { jsx } from "react/jsx-runtime";
+function Signout() {
+  const user = useUser();
+  if (user) {
+    use(user.signOut());
+  }
+  return /* @__PURE__ */ jsx(GoHomeMessageCard, { type: "signedOut", fullPage: true });
+}
+export {
+  Signout as default
+};

package/dist/esm/components-page/sign-up.js

@@ -0,0 +1,12 @@
+"use client";
+"use client";
+
+// src/components-page/sign-up.tsx
+import AuthPage from "./auth-page";
+import { jsx } from "react/jsx-runtime";
+function SignUp({ fullPage = false }) {
+  return /* @__PURE__ */ jsx(AuthPage, { fullPage, type: "sign-up" });
+}
+export {
+  SignUp as default
+};

package/dist/esm/components-page/stack-handler.js

@@ -0,0 +1,75 @@
+// src/components-page/stack-handler.tsx
+import SignUp from "./sign-up";
+import SignIn from "./sign-in";
+import { RedirectType, notFound, redirect } from "next/navigation";
+import EmailVerification from "./email-verification";
+import { PasswordReset } from "..";
+import MessageCard from "../components/message-card";
+import Signout from "./sign-out";
+import ForgotPassword from "./forgot-password";
+import OAuthCallback from "./oauth-callback";
+import AccountSettings from "./account-settings";
+import MagicLinkCallback from "./magic-link-callback";
+import { jsx } from "react/jsx-runtime";
+async function StackHandler({
+  app,
+  params: { stack } = {},
+  searchParams = {}
+}) {
+  if (!stack) {
+    return /* @__PURE__ */ jsx(MessageCard, { title: "Invalid Stack Handler Setup", fullPage: true, children: /* @__PURE__ */ jsx("p", { children: "Can't use Stack handler at this location. Make sure that the file is in a folder called [...stack]." }) });
+  }
+  function redirectIfNotHandler(name) {
+    const url = app.urls[name];
+    const handlerUrl = app.urls.handler;
+    if (url.startsWith(handlerUrl)) {
+      return;
+    }
+    redirect(url, RedirectType.replace);
+  }
+  const path = stack.join("/");
+  switch (path) {
+    case "signin": {
+      redirectIfNotHandler("signIn");
+      return /* @__PURE__ */ jsx(SignIn, { fullPage: true });
+    }
+    case "signup": {
+      redirectIfNotHandler("signUp");
+      return /* @__PURE__ */ jsx(SignUp, { fullPage: true });
+    }
+    case "email-verification": {
+      redirectIfNotHandler("emailVerification");
+      return /* @__PURE__ */ jsx(EmailVerification, { searchParams, fullPage: true });
+    }
+    case "password-reset": {
+      redirectIfNotHandler("passwordReset");
+      return /* @__PURE__ */ jsx(PasswordReset, { searchParams, fullPage: true });
+    }
+    case "forgot-password": {
+      redirectIfNotHandler("forgotPassword");
+      return /* @__PURE__ */ jsx(ForgotPassword, { fullPage: true });
+    }
+    case "signout": {
+      redirectIfNotHandler("signOut");
+      return /* @__PURE__ */ jsx(Signout, {});
+    }
+    case "oauth-callback": {
+      redirectIfNotHandler("oauthCallback");
+      return /* @__PURE__ */ jsx(OAuthCallback, {});
+    }
+    case "account-settings": {
+      redirectIfNotHandler("accountSettings");
+      return /* @__PURE__ */ jsx(AccountSettings, { fullPage: true });
+    }
+    case "magic-link-callback": {
+      redirectIfNotHandler("magicLinkCallback");
+      return /* @__PURE__ */ jsx(MagicLinkCallback, { searchParams, fullPage: true });
+    }
+    default: {
+      return notFound();
+    }
+  }
+}
+export {
+  StackHandler as default
+};

package/dist/esm/index.js

@@ -0,0 +1,47 @@
+// src/index.tsx
+import { default as default2 } from "./providers/stack-provider";
+import { useUser, useStackApp } from "./lib/hooks";
+import { StackClientApp, StackServerApp, StackAdminApp } from "./lib/stack-app";
+import { default as default3 } from "./components-page/stack-handler";
+import { default as default4 } from "./components-page/sign-in";
+import { default as default5 } from "./components-page/sign-up";
+import { default as default6 } from "./components-page/email-verification";
+import { default as default7 } from "./components-page/password-reset";
+import { default as default8 } from "./components-page/forgot-password";
+import { default as default9 } from "./components/message-card";
+import { default as default10 } from "./components/credential-sign-in";
+import { default as default11 } from "./components/credential-sign-up";
+import { default as default12 } from "./components/oauth-button";
+import { default as default13 } from "./components/oauth-group";
+import { default as default14 } from "./components/password-field";
+import { default as default15 } from "./components/user-button";
+import { default as default16 } from "./components-page/account-settings";
+import { useDesign } from "./providers/design-provider";
+import { useComponents } from "./providers/component-provider";
+import { StackTheme } from "./providers/theme-provider";
+export * from "./components-core";
+export {
+  default16 as AccountSettings,
+  default10 as CredentialSignIn,
+  default11 as CredentialSignUp,
+  default6 as EmailVerification,
+  default8 as ForgotPassword,
+  default9 as MessageCard,
+  default12 as OAuthButton,
+  default13 as OAuthGroup,
+  default14 as PasswordField,
+  default7 as PasswordReset,
+  default4 as SignIn,
+  default5 as SignUp,
+  StackAdminApp,
+  StackClientApp,
+  default3 as StackHandler,
+  default2 as StackProvider,
+  StackServerApp,
+  StackTheme,
+  default15 as UserButton,
+  useComponents,
+  useDesign,
+  useStackApp,
+  useUser
+};

package/dist/esm/joy.js

@@ -0,0 +1,5 @@
+// src/joy.tsx
+import { StackJoyTheme } from "./providers/joy-provider";
+export {
+  StackJoyTheme
+};

package/dist/esm/lib/auth.js

@@ -0,0 +1,62 @@
+// src/lib/auth.ts
+import { saveVerifierAndState, getVerifierAndState } from "./cookie";
+import { constructRedirectUrl } from "../utils/url";
+import { neverResolve } from "@stackframe/stack-shared/dist/utils/promises";
+import { StackAssertionError } from "@stackframe/stack-shared/dist/utils/errors";
+async function signInWithOAuth(iface, {
+  provider,
+  redirectUrl
+}) {
+  redirectUrl = constructRedirectUrl(redirectUrl);
+  const { codeChallenge, state } = await saveVerifierAndState();
+  const location = await iface.getOAuthUrl(
+    provider,
+    redirectUrl,
+    codeChallenge,
+    state
+  );
+  window.location.assign(location);
+  await neverResolve();
+}
+function consumeOAuthCallbackQueryParams(expectedState) {
+  const requiredParams = ["code", "state"];
+  const originalUrl = new URL(window.location.href);
+  for (const param of requiredParams) {
+    if (!originalUrl.searchParams.has(param)) {
+      return null;
+    }
+  }
+  if (expectedState !== originalUrl.searchParams.get("state")) {
+    return null;
+  }
+  const newUrl = new URL(originalUrl);
+  for (const param of requiredParams) {
+    newUrl.searchParams.delete(param);
+  }
+  window.history.replaceState({}, "", newUrl.toString());
+  return originalUrl;
+}
+async function callOAuthCallback(iface, tokenStore, redirectUrl) {
+  const { codeVerifier, state } = getVerifierAndState();
+  if (!codeVerifier || !state) {
+    throw new Error("Invalid OAuth callback URL parameters. It seems like the OAuth flow was interrupted, so please try again.");
+  }
+  const originalUrl = consumeOAuthCallbackQueryParams(state);
+  if (!originalUrl)
+    return null;
+  try {
+    return await iface.callOAuthCallback(
+      originalUrl.searchParams,
+      constructRedirectUrl(redirectUrl),
+      codeVerifier,
+      state,
+      tokenStore
+    );
+  } catch (e) {
+    throw new StackAssertionError("Error signing in during OAuth callback. Please try again.", { cause: e });
+  }
+}
+export {
+  callOAuthCallback,
+  signInWithOAuth
+};

package/dist/esm/lib/cookie.js

@@ -0,0 +1,185 @@
+// ../../node_modules/.pnpm/oauth4webapi@2.10.3/node_modules/oauth4webapi/build/index.js
+var USER_AGENT;
+if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) {
+  const NAME = "oauth4webapi";
+  const VERSION = "v2.10.3";
+  USER_AGENT = `${NAME}/${VERSION}`;
+}
+var clockSkew = Symbol();
+var clockTolerance = Symbol();
+var customFetch = Symbol();
+var useMtlsAlias = Symbol();
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function buf(input) {
+  if (typeof input === "string") {
+    return encoder.encode(input);
+  }
+  return decoder.decode(input);
+}
+var CHUNK_SIZE = 32768;
+function encodeBase64Url(input) {
+  if (input instanceof ArrayBuffer) {
+    input = new Uint8Array(input);
+  }
+  const arr = [];
+  for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) {
+    arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+  }
+  return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function decodeBase64Url(input) {
+  try {
+    const binary = atob(input.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, ""));
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  } catch (cause) {
+    throw new OPE("The input to be decoded is not correctly encoded.", { cause });
+  }
+}
+function b64u(input) {
+  if (typeof input === "string") {
+    return decodeBase64Url(input);
+  }
+  return encodeBase64Url(input);
+}
+var LRU = class {
+  constructor(maxSize) {
+    this.cache = /* @__PURE__ */ new Map();
+    this._cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    let v = this.cache.get(key);
+    if (v) {
+      return v;
+    }
+    if (v = this._cache.get(key)) {
+      this.update(key, v);
+      return v;
+    }
+    return void 0;
+  }
+  has(key) {
+    return this.cache.has(key) || this._cache.has(key);
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.set(key, value);
+    } else {
+      this.update(key, value);
+    }
+    return this;
+  }
+  delete(key) {
+    if (this.cache.has(key)) {
+      return this.cache.delete(key);
+    }
+    if (this._cache.has(key)) {
+      return this._cache.delete(key);
+    }
+    return false;
+  }
+  update(key, value) {
+    this.cache.set(key, value);
+    if (this.cache.size >= this.maxSize) {
+      this._cache = this.cache;
+      this.cache = /* @__PURE__ */ new Map();
+    }
+  }
+};
+var OperationProcessingError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = this.constructor.name;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var OPE = OperationProcessingError;
+var dpopNonces = new LRU(100);
+function validateString(input) {
+  return typeof input === "string" && input.length !== 0;
+}
+function randomBytes() {
+  return b64u(crypto.getRandomValues(new Uint8Array(32)));
+}
+function generateRandomCodeVerifier() {
+  return randomBytes();
+}
+function generateRandomState() {
+  return randomBytes();
+}
+async function calculatePKCECodeChallenge(codeVerifier) {
+  if (!validateString(codeVerifier)) {
+    throw new TypeError('"codeVerifier" must be a non-empty string');
+  }
+  return b64u(await crypto.subtle.digest("SHA-256", buf(codeVerifier)));
+}
+var skipSubjectCheck = Symbol();
+var expectNoNonce = Symbol();
+var skipAuthTimeCheck = Symbol();
+var noSignatureCheck = Symbol();
+var skipStateCheck = Symbol();
+var expectNoState = Symbol();
+
+// src/lib/cookie.ts
+import Cookies from "js-cookie";
+import { cookies as rscCookies } from "@stackframe/stack-sc";
+function getCookie(name) {
+  if (rscCookies) {
+    return rscCookies().get(name)?.value ?? null;
+  } else {
+    return Cookies.get(name) ?? null;
+  }
+}
+function setOrDeleteCookie(name, value) {
+  if (value === null) {
+    deleteCookie(name);
+  } else {
+    setCookie(name, value);
+  }
+}
+function deleteCookie(name) {
+  if (rscCookies) {
+    rscCookies().delete(name);
+  } else {
+    Cookies.remove(name);
+  }
+}
+function setCookie(name, value) {
+  if (rscCookies) {
+    rscCookies().set(name, value);
+  } else {
+    Cookies.set(name, value, { secure: window.location.protocol === "https:" });
+  }
+}
+async function saveVerifierAndState() {
+  const codeVerifier = generateRandomCodeVerifier();
+  const codeChallenge = await calculatePKCECodeChallenge(codeVerifier);
+  const state = generateRandomState();
+  setCookie("stack-code-verifier", codeVerifier);
+  setCookie("stack-state", state);
+  return {
+    codeChallenge,
+    state
+  };
+}
+function getVerifierAndState() {
+  const codeVerifier = getCookie("stack-code-verifier");
+  const state = getCookie("stack-state");
+  return {
+    codeVerifier,
+    state
+  };
+}
+export {
+  deleteCookie,
+  getCookie,
+  getVerifierAndState,
+  saveVerifierAndState,
+  setCookie,
+  setOrDeleteCookie
+};

package/dist/esm/lib/hooks.js

@@ -0,0 +1,29 @@
+// src/lib/hooks.ts
+import { StackContext } from "../providers/stack-provider-client";
+import { useContext } from "react";
+function useUser(options = {}) {
+  const stackApp = useStackApp(options);
+  if (options.projectIdMustMatch && stackApp.projectId !== options.projectIdMustMatch) {
+    throw new Error("Unexpected project ID in useStackApp: " + stackApp.projectId);
+  }
+  if (options.projectIdMustMatch === "internal") {
+    return stackApp.useUser(options);
+  } else {
+    return stackApp.useUser(options);
+  }
+}
+function useStackApp(options = {}) {
+  const context = useContext(StackContext);
+  if (context === null) {
+    throw new Error("useStackApp must be used within a StackProvider");
+  }
+  const stackApp = context.app;
+  if (options.projectIdMustMatch && stackApp.projectId !== options.projectIdMustMatch) {
+    throw new Error("Unexpected project ID in useStackApp: " + stackApp.projectId);
+  }
+  return stackApp;
+}
+export {
+  useStackApp,
+  useUser
+};