@openai-oauth/react 2.0.0-beta.0

package/README.md

@@ -0,0 +1,143 @@
+# @openai-oauth/react
+
+[Docs](https://github.com/EvanZhouDev/openai-oauth#react-component) | [GitHub](https://github.com/EvanZhouDev/openai-oauth) | [npm](https://www.npmjs.com/package/@openai-oauth/react)
+
+Let your users sign in with their ChatGPT accounts.
+
+```bash
+npm i @openai-oauth/react
+```
+
+Quickstart:
+
+```tsx
+"use client";
+
+import { SignInWithChatGPT } from "@openai-oauth/react";
+
+export default function Page() {
+	return <SignInWithChatGPT />;
+}
+```
+
+## Package Notes
+
+`SignInWithChatGPT` renders the OpenAI-style sign-in button. After sign-in, it becomes a disconnect button.
+
+The prebuilt button includes a small "Powered by OpenAI OAuth" link by default. Pass `hideAttribution` to render only the button with no attribution link or reserved space.
+
+No app route is required for login. The hook creates the authorization URL, stores PKCE/state in `sessionStorage`, exchanges the callback code directly, and stores the resulting session in the browser session store.
+
+Browser model calls must go through your own app route because ChatGPT does not allow direct browser CORS requests. Send the signed-in session to that route with `openaiAuthHeaders()`:
+
+```tsx
+"use client";
+
+import { openaiAuthHeaders, SignInWithChatGPT } from "@openai-oauth/react";
+
+async function ask() {
+	const response = await fetch("/api/chat", {
+		method: "POST",
+		headers: await openaiAuthHeaders({
+			headers: { "content-type": "application/json" },
+		}),
+		body: JSON.stringify({ prompt: "Hello!" }),
+	});
+
+	return response.text();
+}
+```
+
+Read the request-bound credentials on your server:
+
+```ts
+import { createOpenAIOAuth } from "@openai-oauth/ai-sdk";
+import { openaiCredentials } from "@openai-oauth/react/server";
+import { generateText } from "ai";
+
+export async function POST(request: Request) {
+	const { prompt } = await request.json();
+	const openai = createOpenAIOAuth(openaiCredentials(request));
+
+	const result = await generateText({
+		model: openai("gpt-5.4-mini"),
+		prompt,
+	});
+
+	return Response.json({ text: result.text });
+}
+```
+
+Useful props:
+
+```tsx
+<SignInWithChatGPT
+	onSuccess={(session) => console.log(session.accountId)}
+	onError={(error) => console.error(error.message)}
+	onStateChange={(state) => console.log(state.status)}
+	hideAttribution
+/>
+```
+
+For custom UI, use the hook:
+
+```tsx
+import { useSignInWithChatGPT } from "@openai-oauth/react";
+
+function CustomLogin() {
+	const login = useSignInWithChatGPT();
+
+	if (login.status === "signed-in") {
+		return <button onClick={() => void login.logout()}>Disconnect</button>;
+	}
+
+	return (
+		<button onClick={() => void login.login()}>Sign in with ChatGPT</button>
+	);
+}
+```
+
+The hook returns:
+
+```ts
+type UseSignInWithChatGPTReturn = SignInWithChatGPTState & {
+	isSignedIn: boolean;
+	login(): Promise<void>;
+	logout(): Promise<void>;
+	refresh(): Promise<OpenAIOAuthSession | null>;
+	reset(): void;
+};
+```
+
+State statuses:
+
+```ts
+"checking" | "signed-out" | "starting" | "redirecting" | "signed-in" | "error"
+```
+
+The default browser session store persists encrypted sessions in IndexedDB. Apps can provide their own store:
+
+```ts
+import { createSessionStore } from "@openai-oauth/react";
+
+const sessionStore = createSessionStore();
+
+type SessionStore = {
+	get(): Promise<OpenAIOAuthSession | null>;
+	set(session: OpenAIOAuthSession): Promise<void>;
+	clear(): Promise<void>;
+};
+```
+
+Exports:
+
+- `SignInWithChatGPT`
+- `useSignInWithChatGPT`
+- `openaiAuthHeaders`
+- `getSession`
+- `createSessionStore`
+- `openaiCredentials` from `@openai-oauth/react/server`
+
+## More
+
+[Learn more in the openai-oauth README.](https://github.com/EvanZhouDev/openai-oauth#react-component)

package/dist/SignInWithChatGPT.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonHTMLAttributes } from "react";
+import { type UseSignInWithChatGPTOptions } from "./useSignInWithChatGPT.js";
+export type SignInWithChatGPTProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onError"> & UseSignInWithChatGPTOptions & {
+    loadingLabel?: string;
+    redirectingLabel?: string;
+    signedInLabel?: string;
+    hideAttribution?: boolean;
+    hideWhenSignedIn?: boolean;
+    showLogo?: boolean;
+};
+export declare const SignInWithChatGPT: ({ callbackPath, clientId, codeVerifier, sessionStore, extraParams, fetch, idTokenAddOrganizations, issuer, onSuccess, onError, onStateChange, openMode, redirectUri, scope, simplifiedFlow, state, loadingLabel, redirectingLabel, signedInLabel, hideAttribution, hideWhenSignedIn, showLogo, children, disabled, onClick, onMouseEnter, onMouseLeave, style, type, ...props }: SignInWithChatGPTProps) => import("react").JSX.Element | null;
+//# sourceMappingURL=SignInWithChatGPT.d.ts.map

package/dist/SignInWithChatGPT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignInWithChatGPT.d.ts","sourceRoot":"","sources":["../src/SignInWithChatGPT.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EAIpB,MAAM,OAAO,CAAA;AAEd,OAAO,EACN,KAAK,2BAA2B,EAEhC,MAAM,2BAA2B,CAAA;AAElC,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACxC,oBAAoB,CAAC,iBAAiB,CAAC,EACvC,SAAS,CACT,GACA,2BAA2B,GAAG;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAkEF,eAAO,MAAM,iBAAiB,GAAI,iXA+B/B,sBAAsB,uCA6FxB,CAAA"}

package/dist/SignInWithChatGPT.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useSignInWithChatGPT, } from "./useSignInWithChatGPT.js";
+const containerStyle = {
+    alignItems: "center",
+    display: "inline-flex",
+    flexDirection: "column",
+    gap: 5,
+};
+const buttonStyle = {
+    alignItems: "center",
+    background: "#ffffff",
+    border: "1px solid #d9d9d9",
+    borderRadius: 9999,
+    color: "#111111",
+    cursor: "pointer",
+    display: "inline-flex",
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif',
+    fontSize: 15,
+    fontWeight: 450,
+    gap: 12,
+    justifyContent: "center",
+    lineHeight: 1.2,
+    minHeight: 52,
+    minWidth: 224,
+    padding: "14px 22px",
+    whiteSpace: "nowrap",
+};
+const logoStyle = {
+    display: "block",
+    flex: "0 0 auto",
+    height: 22,
+    width: 22,
+};
+const attributionStyle = {
+    color: "#8f8f8f",
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif',
+    fontSize: 10,
+    fontWeight: 400,
+    lineHeight: 1.2,
+    textDecoration: "underline",
+    textDecorationColor: "currentColor",
+    textUnderlineOffset: 2,
+};
+const OpenAILogo = () => (_jsxs("svg", { "aria-hidden": "true", fill: "none", focusable: "false", style: logoStyle, viewBox: "0 0 5086 5021", xmlns: "http://www.w3.org/2000/svg", children: [_jsx("title", { children: "OpenAI" }), _jsx("path", { d: "M1947.45 1832.08V1357.04C1947.45 1317.03 1962.45 1287.01 1997.43 1267.05L2952.46 717.024C3082.47 642.035 3237.47 607.018 3397.45 607.018C3997.47 607.018 4377.48 1072.05 4377.48 1567.07C4377.48 1602.06 4377.48 1642.06 4372.46 1682.07L3382.45 1102.04C3322.46 1067.03 3262.46 1067.03 3202.45 1102.04L1947.45 1832.08ZM4177.46 3682.19V2547.08C4177.46 2477.08 4147.44 2427.07 4087.45 2392.08L2832.45 1662.05L3242.46 1427.01C3277.44 1407.02 3307.47 1407.02 3342.45 1427.01L4297.47 1977.03C4572.51 2137.05 4757.46 2477.08 4757.46 2807.06C4757.46 3187.06 4532.51 3537.1 4177.46 3682.12V3682.19ZM1652.43 2682.13L1242.42 2442.13C1207.44 2422.14 1192.44 2392.11 1192.44 2352.14V1252.09C1192.44 717.057 1602.45 312.018 2157.48 312.018C2367.47 312.018 2562.43 382.019 2727.5 507.022L1742.48 1077.07C1682.49 1112.05 1652.49 1162.07 1652.49 1232.1V2682.16L1652.43 2682.13ZM2534.98 3192.15L1947.38 2862.13V2162.13L2534.91 1832.11L3122.41 2162.13V2862.13L2534.98 3192.15ZM2912.45 4712.24C2702.43 4712.24 2507.46 4642.21 2342.43 4517.24L3327.42 3947.16C3387.41 3912.17 3417.43 3862.19 3417.43 3792.16V2342.07L3832.46 2582.06C3867.45 2602.05 3882.44 2632.08 3882.44 2672.08V3772.14C3882.44 4307.14 3467.41 4712.24 2912.45 4712.24ZM1727.41 3597.19L772.388 3047.16C497.352 2887.14 312.365 2547.15 312.365 2217.13C312.365 1832.11 542.409 1487.1 897.386 1342.07V2482.13C897.386 2552.17 927.38 2602.15 987.369 2637.13L2237.42 3362.15L1827.41 3597.19C1792.42 3617.17 1762.4 3617.17 1727.41 3597.19ZM1672.45 4417.24C1107.44 4417.24 692.414 3992.18 692.414 3467.16C692.414 3427.16 697.434 3387.15 702.422 3347.15L1687.41 3917.19C1747.42 3952.19 1807.42 3952.19 1867.41 3917.19L3122.41 3192.18V3667.22C3122.41 3707.22 3107.42 3737.22 3072.43 3757.21L2117.41 4307.23C1987.39 4382.22 1832.39 4417.24 1672.38 4417.24H1672.45ZM2912.45 5012.23C3517.46 5012.23 4022.44 4582.22 4137.49 4012.17C4697.48 3867.15 5057.51 3342.13 5057.51 2807.13C5057.51 2457.09 4907.5 2117.1 4637.49 1872.05C4662.49 1767.06 4677.52 1662.05 4677.52 1557.1C4677.52 842.06 4097.49 306.997 3427.48 306.997C3292.5 306.997 3162.48 326.951 3032.46 371.977C2807.44 151.966 2497.45 11.9648 2157.44 11.9648C1552.44 11.9648 1047.46 441.978 932.434 1012.02C372.419 1157.05 12.4219 1682.03 12.4219 2217.06C12.4219 2567.13 162.394 2907.13 432.408 3152.14C407.402 3257.13 392.405 3362.15 392.405 3467.13C392.405 4182.13 972.404 4717.2 1642.45 4717.2C1777.43 4717.2 1907.41 4697.24 2037.43 4652.22C2262.39 4872.23 2572.41 5012.23 2912.45 5012.23Z", fill: "currentColor" })] }));
+export const SignInWithChatGPT = ({ callbackPath, clientId, codeVerifier, sessionStore, extraParams, fetch, idTokenAddOrganizations, issuer, onSuccess, onError, onStateChange, openMode, redirectUri, scope, simplifiedFlow, state, loadingLabel = "Connecting...", redirectingLabel = "Signing in...", signedInLabel = "Disconnect ChatGPT", hideAttribution = false, hideWhenSignedIn = false, showLogo = true, children = "Sign in with ChatGPT", disabled, onClick, onMouseEnter, onMouseLeave, style, type = "button", ...props }) => {
+    const [isHovered, setIsHovered] = useState(false);
+    const login = useSignInWithChatGPT({
+        callbackPath,
+        clientId,
+        codeVerifier,
+        sessionStore,
+        extraParams,
+        fetch,
+        idTokenAddOrganizations,
+        issuer,
+        onSuccess,
+        onError,
+        onStateChange,
+        openMode,
+        redirectUri,
+        scope,
+        simplifiedFlow,
+        state,
+    });
+    const isBusy = login.status === "starting" || login.status === "redirecting";
+    const isSignedIn = login.status === "signed-in";
+    const handleClick = (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented) {
+            return;
+        }
+        if (isSignedIn) {
+            void login.logout();
+            return;
+        }
+        void login.login();
+    };
+    const handleMouseEnter = (event) => {
+        setIsHovered(true);
+        onMouseEnter?.(event);
+    };
+    const handleMouseLeave = (event) => {
+        setIsHovered(false);
+        onMouseLeave?.(event);
+    };
+    if (hideWhenSignedIn && isSignedIn) {
+        return null;
+    }
+    const button = (_jsxs("button", { ...props, type: type, disabled: disabled || isBusy, onClick: handleClick, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, style: {
+            ...buttonStyle,
+            background: isHovered && !disabled && !isBusy ? "#f9f9f9" : "#ffffff",
+            ...style,
+        }, children: [showLogo ? _jsx(OpenAILogo, {}) : null, _jsx("span", { children: login.status === "redirecting"
+                    ? redirectingLabel
+                    : isBusy
+                        ? loadingLabel
+                        : isSignedIn
+                            ? signedInLabel
+                            : children })] }));
+    if (hideAttribution) {
+        return button;
+    }
+    return (_jsxs("span", { style: containerStyle, children: [button, _jsx("a", { href: "https://github.com/EvanZhouDev/openai-oauth", rel: "noreferrer", style: attributionStyle, target: "_blank", children: "Powered by OpenAI OAuth" })] }));
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type BrowserSessionOptions, type BrowserSessionStoreOptions, createSessionStore, getSession, type OpenAIAuthHeadersOptions, openaiAuthHeaders, } from "@openai-oauth/web";
+export { SignInWithChatGPT, type SignInWithChatGPTProps, } from "./SignInWithChatGPT.js";
+export type { OpenAIOAuthSession, SessionStore, SignInWithChatGPTError, SignInWithChatGPTState, } from "./types.js";
+export { type SignInWithChatGPTOpenMode, type UseSignInWithChatGPTOptions, type UseSignInWithChatGPTReturn, useSignInWithChatGPT, } from "./useSignInWithChatGPT.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAC/B,kBAAkB,EAClB,UAAU,EACV,KAAK,wBAAwB,EAC7B,iBAAiB,GACjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACN,iBAAiB,EACjB,KAAK,sBAAsB,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,YAAY,EACX,kBAAkB,EAClB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,GACtB,MAAM,YAAY,CAAA;AACnB,OAAO,EACN,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,oBAAoB,GACpB,MAAM,2BAA2B,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createSessionStore, getSession, openaiAuthHeaders, } from "@openai-oauth/web";
+export { SignInWithChatGPT, } from "./SignInWithChatGPT.js";
+export { useSignInWithChatGPT, } from "./useSignInWithChatGPT.js";

package/dist/next.d.ts

@@ -0,0 +1,4 @@
+export declare const GET: (request: Request) => Promise<Response>;
+export declare const POST: (request: Request) => Promise<Response>;
+export declare const OPTIONS: (request: Request) => Promise<Response>;
+//# sourceMappingURL=next.d.ts.map

package/dist/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../src/next.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,GAAG,GAAI,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAqB,CAAA;AAC5E,eAAO,MAAM,IAAI,GAAI,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAqB,CAAA;AAC7E,eAAO,MAAM,OAAO,GAAI,SAAS,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAqB,CAAA"}

package/dist/next.js

@@ -0,0 +1,5 @@
+import { createRelayHandler } from "@openai-oauth/web";
+const handler = createRelayHandler();
+export const GET = (request) => handler(request);
+export const POST = (request) => handler(request);
+export const OPTIONS = (request) => handler(request);

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+export { openaiCredentials, type WebServerOpenAIOAuthOptions, } from "@openai-oauth/web/server";
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,iBAAiB,EACjB,KAAK,2BAA2B,GAChC,MAAM,0BAA0B,CAAA"}

package/dist/server.js

@@ -0,0 +1 @@
+export { openaiCredentials, } from "@openai-oauth/web/server";

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAIOAuthSession, SessionStore } from "@openai-oauth/core";
+export type { OpenAIOAuthSession, SessionStore };
+export type SignInWithChatGPTError = {
+    code: "invalid-callback" | "popup-blocked" | "request-failed" | "not-authenticated";
+    message: string;
+    cause?: unknown;
+};
+export type SignInWithChatGPTState = {
+    status: "checking";
+    session: null;
+    error: null;
+} | {
+    status: "signed-out";
+    session: null;
+    error: null;
+} | {
+    status: "starting";
+    session: null;
+    error: null;
+} | {
+    status: "redirecting";
+    session: null;
+    error: null;
+} | {
+    status: "signed-in";
+    session: OpenAIOAuthSession;
+    error: null;
+} | {
+    status: "error";
+    session: null;
+    error: SignInWithChatGPTError;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAE1E,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,CAAA;AAEhD,MAAM,MAAM,sBAAsB,GAAG;IACpC,IAAI,EACD,kBAAkB,GAClB,eAAe,GACf,gBAAgB,GAChB,mBAAmB,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC/B;IACA,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;CACV,GACD;IACA,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;CACV,GACD;IACA,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;CACV,GACD;IACA,MAAM,EAAE,aAAa,CAAA;IACrB,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;CACV,GACD;IACA,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,kBAAkB,CAAA;IAC3B,KAAK,EAAE,IAAI,CAAA;CACV,GACD;IACA,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,sBAAsB,CAAA;CAC5B,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/useSignInWithChatGPT.d.ts

@@ -0,0 +1,18 @@
+import { type CompleteLoginOptions, type StartLoginOptions } from "@openai-oauth/web";
+import type { OpenAIOAuthSession, SessionStore, SignInWithChatGPTError, SignInWithChatGPTState } from "./types.js";
+export type SignInWithChatGPTOpenMode = "redirect" | "popup";
+export type UseSignInWithChatGPTOptions = Omit<StartLoginOptions, "returnTo"> & Pick<CompleteLoginOptions, "fetch" | "now" | "tokenUrl"> & {
+    sessionStore?: SessionStore;
+    onStateChange?: (state: SignInWithChatGPTState) => void;
+    onSuccess?: (session: OpenAIOAuthSession) => void;
+    onError?: (error: SignInWithChatGPTError) => void;
+};
+export type UseSignInWithChatGPTReturn = SignInWithChatGPTState & {
+    isSignedIn: boolean;
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+    refresh: () => Promise<OpenAIOAuthSession | null>;
+    reset: () => void;
+};
+export declare const useSignInWithChatGPT: (options?: UseSignInWithChatGPTOptions) => UseSignInWithChatGPTReturn;
+//# sourceMappingURL=useSignInWithChatGPT.d.ts.map

package/dist/useSignInWithChatGPT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignInWithChatGPT.d.ts","sourceRoot":"","sources":["../src/useSignInWithChatGPT.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,oBAAoB,EAKzB,KAAK,iBAAiB,EAEtB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EACX,kBAAkB,EAClB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,yBAAyB,GAAG,UAAU,GAAG,OAAO,CAAA;AAE5D,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,GAC5E,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,KAAK,GAAG,UAAU,CAAC,GAAG;IAC1D,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACvD,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAA;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAA;CACjD,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,sBAAsB,GAAG;IACjE,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3B,OAAO,EAAE,MAAM,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;IACjD,KAAK,EAAE,MAAM,IAAI,CAAA;CACjB,CAAA;AA4CD,eAAO,MAAM,oBAAoB,GAChC,UAAS,2BAAgC,KACvC,0BA2QF,CAAA"}

package/dist/useSignInWithChatGPT.js

@@ -0,0 +1,244 @@
+import { logout as clearLogin, completeLogin, createSessionStore, refreshSession, startLogin, } from "@openai-oauth/web";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+const popupMessageType = "openai-oauth:signed-in";
+const checkingState = {
+    status: "checking",
+    session: null,
+    error: null,
+};
+const signedOutState = {
+    status: "signed-out",
+    session: null,
+    error: null,
+};
+const isBrowser = () => typeof window !== "undefined";
+const toLoginError = (error, code = "request-failed") => ({
+    code,
+    message: error instanceof Error ? error.message : "Sign in with ChatGPT failed.",
+    cause: error,
+});
+const notifyOpener = () => {
+    if (window.opener && window.opener !== window) {
+        window.opener.postMessage({ type: popupMessageType }, window.location.origin);
+        window.setTimeout(() => window.close(), 50);
+    }
+};
+const useLatest = (value) => {
+    const ref = useRef(value);
+    ref.current = value;
+    return ref;
+};
+export const useSignInWithChatGPT = (options = {}) => {
+    const { callbackPath = "/auth/callback", clientId, codeVerifier, sessionStore: providedSessionStore, extraParams, fetch: fetchImpl, idTokenAddOrganizations, issuer, now, onSuccess, onError, onStateChange, openMode = "redirect", redirectUri, scope, simplifiedFlow, state: configuredState, tokenUrl, } = options;
+    const onSuccessRef = useLatest(onSuccess);
+    const onErrorRef = useLatest(onError);
+    const onStateChangeRef = useLatest(onStateChange);
+    const defaultStore = useMemo(() => createSessionStore(), []);
+    const sessionStore = providedSessionStore ?? defaultStore;
+    const [state, setState] = useState(checkingState);
+    const signedInState = useCallback((session) => ({
+        status: "signed-in",
+        session,
+        error: null,
+    }), []);
+    const setLoginState = useCallback((next) => {
+        setState(next);
+        onStateChangeRef.current?.(next);
+    }, [onStateChangeRef]);
+    const fail = useCallback((error, code) => {
+        const loginError = toLoginError(error, code);
+        setLoginState({
+            status: "error",
+            session: null,
+            error: loginError,
+        });
+        onErrorRef.current?.(loginError);
+    }, [onErrorRef, setLoginState]);
+    const loadStoredSession = useCallback(async () => {
+        const session = await sessionStore.get();
+        if (!session) {
+            setLoginState(signedOutState);
+            return;
+        }
+        const next = signedInState(session);
+        setLoginState(next);
+        onSuccessRef.current?.(session);
+    }, [sessionStore, onSuccessRef, setLoginState, signedInState]);
+    const completeCallback = useCallback(async () => {
+        if (!isBrowser()) {
+            return false;
+        }
+        const session = await completeLogin({
+            clientId,
+            fetch: fetchImpl,
+            issuer,
+            now,
+            sessionStore,
+            tokenUrl,
+        });
+        if (!session) {
+            return false;
+        }
+        const next = signedInState(session);
+        setLoginState(next);
+        onSuccessRef.current?.(session);
+        notifyOpener();
+        return true;
+    }, [
+        clientId,
+        fetchImpl,
+        issuer,
+        now,
+        sessionStore,
+        tokenUrl,
+        onSuccessRef,
+        setLoginState,
+        signedInState,
+    ]);
+    useEffect(() => {
+        if (!isBrowser()) {
+            setLoginState(signedOutState);
+            return;
+        }
+        let current = true;
+        void (async () => {
+            try {
+                const completed = await completeCallback();
+                if (!current || completed) {
+                    return;
+                }
+                await loadStoredSession();
+            }
+            catch (error) {
+                if (current) {
+                    fail(error, "invalid-callback");
+                }
+            }
+        })();
+        return () => {
+            current = false;
+        };
+    }, [completeCallback, fail, loadStoredSession, setLoginState]);
+    useEffect(() => {
+        if (!isBrowser()) {
+            return;
+        }
+        const onMessage = (event) => {
+            if (event.origin === window.location.origin &&
+                typeof event.data === "object" &&
+                event.data !== null &&
+                "type" in event.data &&
+                event.data.type === popupMessageType) {
+                void loadStoredSession();
+            }
+        };
+        window.addEventListener("message", onMessage);
+        return () => window.removeEventListener("message", onMessage);
+    }, [loadStoredSession]);
+    const login = useCallback(async () => {
+        if (!isBrowser()) {
+            fail(new Error("Sign in with ChatGPT can only start in a browser."));
+            return;
+        }
+        try {
+            setLoginState({
+                status: "starting",
+                session: null,
+                error: null,
+            });
+            await startLogin({
+                callbackPath,
+                clientId,
+                codeVerifier,
+                extraParams,
+                idTokenAddOrganizations,
+                issuer,
+                openMode,
+                redirectUri,
+                scope,
+                simplifiedFlow,
+                state: configuredState,
+            });
+            setLoginState({
+                status: "redirecting",
+                session: null,
+                error: null,
+            });
+        }
+        catch (error) {
+            fail(error, error instanceof Error &&
+                error.message === "The ChatGPT login popup was blocked."
+                ? "popup-blocked"
+                : undefined);
+        }
+    }, [
+        callbackPath,
+        clientId,
+        codeVerifier,
+        configuredState,
+        extraParams,
+        fail,
+        idTokenAddOrganizations,
+        issuer,
+        openMode,
+        redirectUri,
+        scope,
+        setLoginState,
+        simplifiedFlow,
+    ]);
+    const logout = useCallback(async () => {
+        await clearLogin({ sessionStore });
+        setLoginState(signedOutState);
+    }, [sessionStore, setLoginState]);
+    const refresh = useCallback(async () => {
+        try {
+            const session = state.session ?? (await sessionStore.get());
+            if (!session?.refreshToken) {
+                fail(new Error("No refresh token is available."), "not-authenticated");
+                return null;
+            }
+            const refreshed = await refreshSession({
+                refreshToken: session.refreshToken,
+            }, {
+                clientId,
+                fetch: fetchImpl,
+                issuer,
+                now,
+                tokenUrl,
+            });
+            await sessionStore.set(refreshed);
+            const next = signedInState(refreshed);
+            setLoginState(next);
+            onSuccessRef.current?.(refreshed);
+            return refreshed;
+        }
+        catch (error) {
+            fail(error);
+            return null;
+        }
+    }, [
+        clientId,
+        fail,
+        fetchImpl,
+        issuer,
+        now,
+        onSuccessRef,
+        sessionStore,
+        setLoginState,
+        signedInState,
+        state.session,
+        tokenUrl,
+    ]);
+    const reset = useCallback(() => {
+        void clearLogin({ sessionStore });
+        setLoginState(signedOutState);
+    }, [sessionStore, setLoginState]);
+    return {
+        ...state,
+        isSignedIn: state.status === "signed-in",
+        login,
+        logout,
+        refresh,
+        reset,
+    };
+};