@stackframe/stack 2.3.5 → 2.3.8

package/dist/joy.js

@@ -1 +1,30 @@
-export { StackJoyTheme } from './providers/joy-provider';
+"use strict";
+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);
+
+// src/joy.tsx
+var joy_exports = {};
+__export(joy_exports, {
+  StackJoyTheme: () => import_joy_provider.StackJoyTheme
+});
+module.exports = __toCommonJS(joy_exports);
+var import_joy_provider = require("./providers/joy-provider");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StackJoyTheme
+});

package/dist/lib/auth.d.mts

@@ -0,0 +1,11 @@
+import * as oauth4webapi from 'oauth4webapi';
+import { StackClientInterface } from '@stackframe/stack-shared';
+import { TokenStore } from '@stackframe/stack-shared/dist/interface/clientInterface';
+
+declare function signInWithOAuth(iface: StackClientInterface, { provider, redirectUrl, }: {
+    provider: string;
+    redirectUrl?: string;
+}): Promise<void>;
+declare function callOAuthCallback(iface: StackClientInterface, tokenStore: TokenStore, redirectUrl: string): Promise<oauth4webapi.OAuth2TokenEndpointResponse | null>;
+
+export { callOAuthCallback, signInWithOAuth };

package/dist/lib/auth.d.ts

@@ -1,7 +1,11 @@
-import { StackClientInterface } from "@stackframe/stack-shared";
-import { TokenStore } from "@stackframe/stack-shared/dist/interface/clientInterface";
-export declare function signInWithOAuth(iface: StackClientInterface, { provider, redirectUrl, }: {
+import * as oauth4webapi from 'oauth4webapi';
+import { StackClientInterface } from '@stackframe/stack-shared';
+import { TokenStore } from '@stackframe/stack-shared/dist/interface/clientInterface';
+
+declare function signInWithOAuth(iface: StackClientInterface, { provider, redirectUrl, }: {
     provider: string;
     redirectUrl?: string;
 }): Promise<void>;
-export declare function callOAuthCallback(iface: StackClientInterface, tokenStore: TokenStore, redirectUrl: string): Promise<import("oauth4webapi").OAuth2TokenEndpointResponse | null>;
+declare function callOAuthCallback(iface: StackClientInterface, tokenStore: TokenStore, redirectUrl: string): Promise<oauth4webapi.OAuth2TokenEndpointResponse | null>;
+
+export { callOAuthCallback, signInWithOAuth };

package/dist/lib/auth.js

@@ -1,62 +1,88 @@
-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";
-export 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();
+"use strict";
+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);
+
+// src/lib/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  callOAuthCallback: () => callOAuthCallback,
+  signInWithOAuth: () => signInWithOAuth
+});
+module.exports = __toCommonJS(auth_exports);
+var import_cookie = require("./cookie");
+var import_url = require("../utils/url");
+var import_promises = require("@stackframe/stack-shared/dist/utils/promises");
+var import_errors = require("@stackframe/stack-shared/dist/utils/errors");
+async function signInWithOAuth(iface, {
+  provider,
+  redirectUrl
+}) {
+  redirectUrl = (0, import_url.constructRedirectUrl)(redirectUrl);
+  const { codeChallenge, state } = await (0, import_cookie.saveVerifierAndState)();
+  const location = await iface.getOAuthUrl(
+    provider,
+    redirectUrl,
+    codeChallenge,
+    state
+  );
+  window.location.assign(location);
+  await (0, import_promises.neverResolve)();
 }
-/**
- * Checks if the current URL has the query parameters for an OAuth callback, and if so, removes them.
- *
- * Must be synchronous for the logic in callOAuthCallback to work without race conditions.
- */
 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;
-        }
+  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")) {
-        // If the state doesn't match, then the callback wasn't meant for us.
-        // Maybe the website uses another OAuth library?
-        return null;
-    }
-    const newUrl = new URL(originalUrl);
-    for (const param of requiredParams) {
-        newUrl.searchParams.delete(param);
-    }
-    // let's get rid of the authorization code in the history as we
-    // don't redirect to `redirectUrl` if there's a validation error
-    // (as the redirectUrl might be malicious!).
-    //
-    // We use history.replaceState instead of location.assign(...) to
-    // prevent an unnecessary reload
-    window.history.replaceState({}, "", newUrl.toString());
-    return originalUrl;
+  }
+  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;
 }
-export async function callOAuthCallback(iface, tokenStore, redirectUrl) {
-    // note: this part of the function (until the return) needs
-    // to be synchronous, to prevent race conditions when
-    // callOAuthCallback is called multiple times in parallel
-    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;
-    // the rest can be asynchronous (we now know that we are the
-    // intended recipient of the callback)
-    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 });
-    }
+async function callOAuthCallback(iface, tokenStore, redirectUrl) {
+  const { codeVerifier, state } = (0, import_cookie.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,
+      (0, import_url.constructRedirectUrl)(redirectUrl),
+      codeVerifier,
+      state,
+      tokenStore
+    );
+  } catch (e) {
+    throw new import_errors.StackAssertionError("Error signing in during OAuth callback. Please try again.", { cause: e });
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callOAuthCallback,
+  signInWithOAuth
+});

package/dist/lib/cookie.d.mts

@@ -0,0 +1,14 @@
+declare function getCookie(name: string): string | null;
+declare function setOrDeleteCookie(name: string, value: string | null): void;
+declare function deleteCookie(name: string): void;
+declare function setCookie(name: string, value: string): void;
+declare function saveVerifierAndState(): Promise<{
+    codeChallenge: string;
+    state: string;
+}>;
+declare function getVerifierAndState(): {
+    codeVerifier: string | null;
+    state: string | null;
+};
+
+export { deleteCookie, getCookie, getVerifierAndState, saveVerifierAndState, setCookie, setOrDeleteCookie };

package/dist/lib/cookie.d.ts

@@ -1,12 +1,14 @@
-export declare function getCookie(name: string): string | null;
-export declare function setOrDeleteCookie(name: string, value: string | null): void;
-export declare function deleteCookie(name: string): void;
-export declare function setCookie(name: string, value: string): void;
-export declare function saveVerifierAndState(): Promise<{
+declare function getCookie(name: string): string | null;
+declare function setOrDeleteCookie(name: string, value: string | null): void;
+declare function deleteCookie(name: string): void;
+declare function setCookie(name: string, value: string): void;
+declare function saveVerifierAndState(): Promise<{
     codeChallenge: string;
     state: string;
 }>;
-export declare function getVerifierAndState(): {
+declare function getVerifierAndState(): {
     codeVerifier: string | null;
     state: string | null;
 };
+
+export { deleteCookie, getCookie, getVerifierAndState, saveVerifierAndState, setCookie, setOrDeleteCookie };

package/dist/lib/cookie.js

@@ -1,55 +1,227 @@
-import { generateRandomCodeVerifier, generateRandomState, calculatePKCECodeChallenge } from "oauth4webapi";
-import Cookies from "js-cookie";
-import { cookies as rscCookies } from '@stackframe/stack-sc';
-export function getCookie(name) {
-    // TODO the differentiating factor should be RCC vs. RSC, not whether it's a client
-    if (rscCookies) {
-        return rscCookies().get(name)?.value ?? null;
-    }
-    else {
-        return Cookies.get(name) ?? null;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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);
+
+// src/lib/cookie.ts
+var cookie_exports = {};
+__export(cookie_exports, {
+  deleteCookie: () => deleteCookie,
+  getCookie: () => getCookie,
+  getVerifierAndState: () => getVerifierAndState,
+  saveVerifierAndState: () => saveVerifierAndState,
+  setCookie: () => setCookie,
+  setOrDeleteCookie: () => setOrDeleteCookie
+});
+module.exports = __toCommonJS(cookie_exports);
+
+// ../../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 });
+  }
 }
-export function setOrDeleteCookie(name, value) {
-    if (value === null) {
-        deleteCookie(name);
+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;
     }
-    else {
-        setCookie(name, value);
+    if (v = this._cache.get(key)) {
+      this.update(key, v);
+      return v;
     }
-}
-export function deleteCookie(name) {
-    if (rscCookies) {
-        rscCookies().delete(name);
+    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);
     }
-    else {
-        Cookies.remove(name);
+    return this;
+  }
+  delete(key) {
+    if (this.cache.has(key)) {
+      return this.cache.delete(key);
     }
-}
-export function setCookie(name, value) {
-    if (rscCookies) {
-        rscCookies().set(name, value);
+    if (this._cache.has(key)) {
+      return this._cache.delete(key);
     }
-    else {
-        Cookies.set(name, value, { secure: window.location.protocol === "https:" });
+    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
+var import_js_cookie = __toESM(require("js-cookie"));
+var import_stack_sc = require("@stackframe/stack-sc");
+function getCookie(name) {
+  if (import_stack_sc.cookies) {
+    return (0, import_stack_sc.cookies)().get(name)?.value ?? null;
+  } else {
+    return import_js_cookie.default.get(name) ?? null;
+  }
+}
+function setOrDeleteCookie(name, value) {
+  if (value === null) {
+    deleteCookie(name);
+  } else {
+    setCookie(name, value);
+  }
+}
+function deleteCookie(name) {
+  if (import_stack_sc.cookies) {
+    (0, import_stack_sc.cookies)().delete(name);
+  } else {
+    import_js_cookie.default.remove(name);
+  }
+}
+function setCookie(name, value) {
+  if (import_stack_sc.cookies) {
+    (0, import_stack_sc.cookies)().set(name, value);
+  } else {
+    import_js_cookie.default.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
+  };
 }
-export 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,
-    };
-}
-export function getVerifierAndState() {
-    const codeVerifier = getCookie("stack-code-verifier");
-    const state = getCookie("stack-state");
-    return {
-        codeVerifier,
-        state,
-    };
+function getVerifierAndState() {
+  const codeVerifier = getCookie("stack-code-verifier");
+  const state = getCookie("stack-state");
+  return {
+    codeVerifier,
+    state
+  };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCookie,
+  getCookie,
+  getVerifierAndState,
+  saveVerifierAndState,
+  setCookie,
+  setOrDeleteCookie
+});

package/dist/lib/hooks.d.mts

@@ -0,0 +1,35 @@
+import { CurrentInternalUser, CurrentUser, StackClientApp, GetUserOptions as GetUserOptions$1 } from './stack-app.mjs';
+import '@stackframe/stack-shared';
+import '@stackframe/stack-shared/dist/interface/clientInterface';
+import '@stackframe/stack-shared/dist/utils/json';
+import '@stackframe/stack-shared/dist/interface/adminInterface';
+
+/**
+ * Returns the current user object. Equivalent to `useStackApp().useUser()`.
+ *
+ * @returns the current user
+ */
+type GetUserOptions = GetUserOptions$1 & {
+    projectIdMustMatch?: string;
+};
+declare function useUser(options: GetUserOptions & {
+    or: 'redirect' | 'throw';
+    projectIdMustMatch: "internal";
+}): CurrentInternalUser;
+declare function useUser(options: GetUserOptions & {
+    or: 'redirect' | 'throw';
+}): CurrentUser;
+declare function useUser(options: GetUserOptions & {
+    projectIdMustMatch: "internal";
+}): CurrentInternalUser | null;
+declare function useUser(options?: GetUserOptions): CurrentUser | CurrentInternalUser | null;
+/**
+ * Returns the current Stack app associated with the StackProvider.
+ *
+ * @returns the current Stack app
+ */
+declare function useStackApp<ProjectId extends string>(options?: {
+    projectIdMustMatch?: ProjectId;
+}): StackClientApp<true, ProjectId>;
+
+export { useStackApp, useUser };

package/dist/lib/hooks.d.ts

@@ -1,29 +1,35 @@
-import { CurrentUser, GetUserOptions as AppGetUserOptions, StackClientApp, CurrentInternalUser } from "./stack-app";
+import { CurrentInternalUser, CurrentUser, StackClientApp, GetUserOptions as GetUserOptions$1 } from './stack-app.js';
+import '@stackframe/stack-shared';
+import '@stackframe/stack-shared/dist/interface/clientInterface';
+import '@stackframe/stack-shared/dist/utils/json';
+import '@stackframe/stack-shared/dist/interface/adminInterface';
+
 /**
  * Returns the current user object. Equivalent to `useStackApp().useUser()`.
  *
  * @returns the current user
  */
-type GetUserOptions = AppGetUserOptions & {
+type GetUserOptions = GetUserOptions$1 & {
     projectIdMustMatch?: string;
 };
-export declare function useUser(options: GetUserOptions & {
+declare function useUser(options: GetUserOptions & {
     or: 'redirect' | 'throw';
     projectIdMustMatch: "internal";
 }): CurrentInternalUser;
-export declare function useUser(options: GetUserOptions & {
+declare function useUser(options: GetUserOptions & {
     or: 'redirect' | 'throw';
 }): CurrentUser;
-export declare function useUser(options: GetUserOptions & {
+declare function useUser(options: GetUserOptions & {
     projectIdMustMatch: "internal";
 }): CurrentInternalUser | null;
-export declare function useUser(options?: GetUserOptions): CurrentUser | CurrentInternalUser | null;
+declare function useUser(options?: GetUserOptions): CurrentUser | CurrentInternalUser | null;
 /**
  * Returns the current Stack app associated with the StackProvider.
  *
  * @returns the current Stack app
  */
-export declare function useStackApp<ProjectId extends string>(options?: {
+declare function useStackApp<ProjectId extends string>(options?: {
     projectIdMustMatch?: ProjectId;
 }): StackClientApp<true, ProjectId>;
-export {};
+
+export { useStackApp, useUser };