@leisuresaas/react 0.1.2-dev.1 → 0.1.2-dev.2

package/README.md

@@ -5,7 +5,7 @@
 没有 Expo，也没有 Integration Key。App 用 `@leisuresaas/react-native`。
 
 ```ts
-import { loginProductAccount } from "@leisuresaas/react/auth";
+import { login } from "@leisuresaas/react/auth";
 import { beginPlatformLogin } from "@leisuresaas/react/oauth";
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leisuresaas/react",
-  "version": "0.1.2-dev.1",
+  "version": "0.1.2-dev.2",
   "description": "Browser SDK for LeisureSaas: product auth, OAuth PKCE, Public Ads, Drive. No Expo or Integration Key.",
   "license": "MIT",
   "repository": {

package/src/auth-provider.tsx

@@ -3,43 +3,43 @@
 import { createContext, useCallback, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
 
 import {
-  loginProductAccount,
-  logoutProductAccount,
-  refreshProductSession,
-  registerProductAccount,
-  type ProductAuthTokens,
+  login,
+  logout,
+  refreshSession,
+  register,
+  type AuthTokens,
   type PublicAuthContext,
 } from "./auth";
 import { accessNeedsRefresh } from "./oauth";
 
 const STORAGE_KEY = "leisuresaas_product_session";
 
-type ProductAuthState = {
-  tokens: ProductAuthTokens | null;
+type AuthState = {
+  tokens: AuthTokens | null;
   ready: boolean;
   login: (input: { email: string; password: string }) => Promise<void>;
   register: (input: { email: string; password: string; name?: string }) => Promise<{ verificationRequired: boolean }>;
   logout: () => Promise<void>;
 };
 
-const ProductAuthContext = createContext<ProductAuthState | null>(null);
+const AuthContext = createContext<AuthState | null>(null);
 
-function readStored(): ProductAuthTokens | null {
+function readStored(): AuthTokens | null {
   if (typeof sessionStorage === "undefined") return null;
   const raw = sessionStorage.getItem(STORAGE_KEY);
   if (!raw) return null;
   try {
-    return JSON.parse(raw) as ProductAuthTokens;
+    return JSON.parse(raw) as AuthTokens;
   } catch {
     return null;
   }
 }
 
-export function ProductAuthProvider({ context, children }: { context: PublicAuthContext; children: ReactNode }) {
-  const [tokens, setTokens] = useState<ProductAuthTokens | null>(null);
+export function AuthProvider({ context, children }: { context: PublicAuthContext; children: ReactNode }) {
+  const [tokens, setTokens] = useState<AuthTokens | null>(null);
   const [ready, setReady] = useState(false);
 
-  const persist = useCallback((next: ProductAuthTokens | null) => {
+  const persist = useCallback((next: AuthTokens | null) => {
     setTokens(next);
     if (typeof sessionStorage === "undefined") return;
     if (!next) sessionStorage.removeItem(STORAGE_KEY);
@@ -57,34 +57,39 @@ export function ProductAuthProvider({ context, children }: { context: PublicAuth
       setReady(true);
       return;
     }
-    void refreshProductSession(context, stored.refreshToken)
+    void refreshSession(context, stored.refreshToken)
       .then((next) => persist(next))
       .catch(() => persist(null))
       .finally(() => setReady(true));
   }, [context, persist]);
 
-  const value = useMemo<ProductAuthState>(() => ({
+  const value = useMemo<AuthState>(() => ({
     tokens,
     ready,
     login: async (input) => {
-      persist(await loginProductAccount(context, input));
+      persist(await login(context, input));
     },
-    register: async (input) => registerProductAccount(context, input),
+    register: async (input) => register(context, input),
     logout: async () => {
       if (tokens?.accessToken) {
-        await logoutProductAccount(context, tokens.accessToken, tokens.refreshToken).catch(() => undefined);
+        await logout(context, tokens.accessToken, tokens.refreshToken).catch(() => undefined);
       }
       persist(null);
     },
   }), [tokens, ready, context, persist]);
 
-  return <ProductAuthContext.Provider value={value}>{children}</ProductAuthContext.Provider>;
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
 }
 
-export function useProductAuth(): ProductAuthState {
-  const ctx = useContext(ProductAuthContext);
+export function useAuth(): AuthState {
+  const ctx = useContext(AuthContext);
   if (!ctx) {
-    throw new Error("useProductAuth must be used within ProductAuthProvider");
+    throw new Error("useAuth must be used within AuthProvider");
   }
   return ctx;
 }
+
+/** @deprecated Use AuthProvider. */
+export const ProductAuthProvider = AuthProvider;
+/** @deprecated Use useAuth. */
+export const useProductAuth = useAuth;

package/src/auth.ts

@@ -10,7 +10,7 @@ export type PublicAuthContext = {
   origin: string;
 };
 
-export type ProductAuthTokens = {
+export type AuthTokens = {
   accessToken: string;
   refreshToken: string;
   accessExpiresAtUnix: number;
@@ -70,7 +70,7 @@ async function publicAuthRequest<T>(
   return JSON.parse(text) as T;
 }
 
-function tokensFromJSON(data: TokenJSON): ProductAuthTokens {
+function tokensFromJSON(data: TokenJSON): AuthTokens {
   const accessToken = data.access_token?.trim() ?? "";
   if (!accessToken) {
     throw new LeisureSaasHttpError(502, "missing access_token");
@@ -85,7 +85,7 @@ function tokensFromJSON(data: TokenJSON): ProductAuthTokens {
   };
 }
 
-export async function registerProductAccount(
+export async function register(
   ctx: PublicAuthContext,
   input: { email: string; password: string; name?: string; locale?: string },
 ): Promise<{ verificationRequired: boolean }> {
@@ -95,48 +95,48 @@ export async function registerProductAccount(
   return { verificationRequired: resp.verification_required !== false };
 }
 
-export async function loginProductAccount(
+export async function login(
   ctx: PublicAuthContext,
   input: { email: string; password: string; locale?: string },
-): Promise<ProductAuthTokens> {
+): Promise<AuthTokens> {
   const resp = await publicAuthRequest<TokenJSON>(ctx, "/login", {
     email: input.email, password: input.password, locale: input.locale ?? "",
   });
   return tokensFromJSON(resp);
 }
 
-export async function refreshProductSession(ctx: PublicAuthContext, refreshToken: string): Promise<ProductAuthTokens> {
+export async function refreshSession(ctx: PublicAuthContext, refreshToken: string): Promise<AuthTokens> {
   const resp = await publicAuthRequest<TokenJSON>(ctx, "/refresh", { refresh_token: refreshToken });
   return tokensFromJSON(resp);
 }
 
-export async function requestProductPasswordReset(
+export async function requestPasswordReset(
   ctx: PublicAuthContext,
   input: { email: string; locale?: string },
 ): Promise<void> {
   await publicAuthRequest(ctx, "/password-reset", { email: input.email, locale: input.locale ?? "" });
 }
 
-export async function requestProductEmailVerification(
+export async function requestEmailVerification(
   ctx: PublicAuthContext,
   input: { email: string; locale?: string },
 ): Promise<void> {
   await publicAuthRequest(ctx, "/email-verification", { email: input.email, locale: input.locale ?? "" });
 }
 
-export async function confirmProductEmailVerification(ctx: PublicAuthContext, token: string): Promise<ProductAuthTokens> {
+export async function confirmEmailVerification(ctx: PublicAuthContext, token: string): Promise<AuthTokens> {
   const resp = await publicAuthRequest<TokenJSON>(ctx, "/email-verification/confirm", { token });
   return tokensFromJSON(resp);
 }
 
-export async function confirmProductPasswordReset(
+export async function confirmPasswordReset(
   ctx: PublicAuthContext,
   input: { token: string; newPassword: string },
 ): Promise<void> {
   await publicAuthRequest(ctx, "/password-reset/confirm", { token: input.token, new_password: input.newPassword });
 }
 
-export async function changeProductPassword(
+export async function changePassword(
   ctx: PublicAuthContext,
   accessToken: string,
   input: { currentPassword: string; newPassword: string },
@@ -146,7 +146,7 @@ export async function changeProductPassword(
   }, accessToken);
 }
 
-export async function logoutProductAccount(
+export async function logout(
   ctx: PublicAuthContext,
   accessToken: string,
   refreshToken?: string,
@@ -154,7 +154,7 @@ export async function logoutProductAccount(
   await publicAuthRequest(ctx, "/logout", { refresh_token: refreshToken ?? "" }, accessToken);
 }
 
-export async function deleteProductAccount(ctx: PublicAuthContext, accessToken: string): Promise<void> {
+export async function deleteAccount(ctx: PublicAuthContext, accessToken: string): Promise<void> {
   await publicAuthRequest(ctx, "/account/delete", {}, accessToken);
 }
 
@@ -187,3 +187,26 @@ export async function bindPlatformAccount(
 export async function unbindPlatformAccount(ctx: PublicAuthContext, accessToken: string): Promise<void> {
   await publicAuthRequest(ctx, "/unbind", {}, accessToken);
 }
+
+/** @deprecated Use AuthTokens. */
+export type ProductAuthTokens = AuthTokens;
+/** @deprecated Use register. */
+export const registerProductAccount = register;
+/** @deprecated Use login. */
+export const loginProductAccount = login;
+/** @deprecated Use logout. */
+export const logoutProductAccount = logout;
+/** @deprecated Use refreshSession. */
+export const refreshProductSession = refreshSession;
+/** @deprecated Use deleteAccount. */
+export const deleteProductAccount = deleteAccount;
+/** @deprecated Use changePassword. */
+export const changeProductPassword = changePassword;
+/** @deprecated Use requestPasswordReset. */
+export const requestProductPasswordReset = requestPasswordReset;
+/** @deprecated Use confirmPasswordReset. */
+export const confirmProductPasswordReset = confirmPasswordReset;
+/** @deprecated Use requestEmailVerification. */
+export const requestProductEmailVerification = requestEmailVerification;
+/** @deprecated Use confirmEmailVerification. */
+export const confirmProductEmailVerification = confirmEmailVerification;

package/src/index.ts

@@ -6,21 +6,31 @@ export type { ResolvePlatformApiBaseOptions } from "./platform-api-base";
 
 export {
   bindPlatformAccount,
+  changePassword,
   changeProductPassword,
+  confirmEmailVerification,
+  confirmPasswordReset,
+  confirmProductEmailVerification,
+  confirmProductPasswordReset,
+  deleteAccount,
   deleteProductAccount,
+  login,
   loginProductAccount,
+  logout,
   logoutProductAccount,
   refreshProductSession,
+  refreshSession,
+  register,
   registerProductAccount,
-  confirmProductEmailVerification,
-  confirmProductPasswordReset,
+  requestEmailVerification,
+  requestPasswordReset,
   requestProductEmailVerification,
   requestProductPasswordReset,
   startPlatformAuthorize,
   unbindPlatformAccount,
 } from "./auth";
-export type { ProductAuthTokens, PublicAuthContext } from "./auth";
-export { ProductAuthProvider, useProductAuth } from "./auth-provider";
+export type { AuthTokens, ProductAuthTokens, PublicAuthContext } from "./auth";
+export { AuthProvider, ProductAuthProvider, useAuth, useProductAuth } from "./auth-provider";
 
 export {
   accessNeedsRefresh,

package/src/oauth.ts

@@ -1,4 +1,4 @@
-import { startPlatformAuthorize, type PublicAuthContext, type ProductAuthTokens } from "./auth";
+import { startPlatformAuthorize, type AuthTokens, type PublicAuthContext } from "./auth";
 
 const REFRESH_SKEW_SEC = 60;
 
@@ -214,7 +214,7 @@ function jwtClaims(accessToken: string): Record<string, unknown> {
   }
 }
 
-export function productTokensFromOAuth(tokens: OAuthTokenResponse): ProductAuthTokens {
+export function productTokensFromOAuth(tokens: OAuthTokenResponse): AuthTokens {
   const now = Math.floor(Date.now() / 1000);
   const claims = jwtClaims(tokens.accessToken);
   return {
@@ -248,7 +248,7 @@ export async function completePlatformLogin(input: {
   code: string;
   redirectUri: string;
   verifier: string;
-}): Promise<ProductAuthTokens> {
+}): Promise<AuthTokens> {
   const authorize = new URL(input.authorizationUrl);
   const clientId = authorize.searchParams.get("client_id")?.trim() ?? "";
   const issuer = `${authorize.protocol}//${authorize.host}`;