@niledatabase/react 3.0.1-alpha.0 → 4.0.0-alpha.0

package/dist/index.d.ts

@@ -3,18 +3,17 @@ import React__default from 'react';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient } from '@tanstack/react-query';
 import * as next_auth_react from 'next-auth/react';
-import { SignInOptions, UseSessionOptions, LiteralUnion, ClientSafeProvider, SignInAuthorizationParams, SignInResponse, SignOutParams, SignOutResponse, SessionProviderProps } from 'next-auth/react';
+import { SignInOptions, LiteralUnion, ClientSafeProvider, SignOutParams, SignOutResponse, SignInAuthorizationParams, SignInResponse, UseSessionOptions } from 'next-auth/react';
 import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
 import { VariantProps } from 'class-variance-authority';
 import { CreateBasicUserRequest } from '@niledatabase/browser';
-import { BuiltInProviderType, RedirectableProviderType } from 'next-auth/providers/index';
 import { CtxOrReq } from 'next-auth/client/_utils';
-import { Session } from 'next-auth';
+import { BuiltInProviderType, RedirectableProviderType } from 'next-auth/providers/index';
 
 type EmailSignInInfo = SignInOptions;
 type SignInSuccess = (response: Response) => void;
 type AllowedAny$3 = any;
-interface Props$5 {
+type Props$4 = {
     redirect?: boolean;
     onSuccess?: SignInSuccess;
     onError?: (e: Error, info: EmailSignInInfo) => void;
@@ -22,9 +21,10 @@ interface Props$5 {
     buttonText?: string;
     client?: QueryClient;
     callbackUrl?: string;
-}
+    init?: RequestInit;
+};
 
-declare function EmailSigningIn(props: Props$5): React__default.JSX.Element;
+declare function EmailSigningIn(props: Props$4): React__default.JSX.Element;
 
 declare const buttonVariants: (props?: ({
     variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
@@ -59,7 +59,7 @@ declare const EmailSignInButton: React__default.ForwardRefExoticComponent<Button
     buttonText?: string;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
-declare function useEmailSignIn(params?: Props$5): _tanstack_react_query.UseMutateFunction<Response, Error, next_auth_react.SignInOptions, unknown>;
+declare function useEmailSignIn(params?: Props$4): _tanstack_react_query.UseMutateFunction<Response, Error, next_auth_react.SignInOptions, unknown>;
 
 /**
  * A component for a Google login button, according to their design language.
@@ -70,43 +70,217 @@ declare function useEmailSignIn(params?: Props$5): _tanstack_react_query.UseMuta
 declare const GoogleSSOButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const AzureSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const DiscordSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const GitHubSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const HubSpotSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const LinkedInSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const SlackSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: ResponseInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
 declare const XSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
     callbackUrl?: string;
     buttonText?: string;
+    init?: RequestInit;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
+type JWT = {
+    email: string;
+    sub: string;
+    id: string;
+    iat: number;
+    exp: number;
+    jti: string;
+    loading: boolean;
+};
+type ActiveSession = {
+    loading: boolean;
+    id: string;
+    email: string;
+    expires: string;
+    user?: {
+        id: string;
+        name: string;
+        image: string;
+        email: string;
+        emailVerified: void | Date;
+    };
+};
+type NonErrorSession = JWT | ActiveSession | null | undefined;
+type NileSession = Response | NonErrorSession;
+type AuthState = {
+    basePath: string;
+    baseUrl: string;
+    lastSync: number;
+    getSession: (...args: any[]) => void;
+    session: NonErrorSession | undefined | null;
+    loading: boolean;
+};
+type ListenerParams = {
+    key: ListenerKeys;
+    next: any;
+    prev: any;
+};
+type Listener = (callback: ListenerParams) => void;
+type ListenerKeys = 'basePath' | 'baseUrl' | 'lastSync' | 'getSession' | 'session' | 'loading';
+type AuthConfig = Config & {
+    listenerKeys?: Array<ListenerKeys>;
+};
+type Config = {
+    basePath?: string;
+    baseUrl?: string;
+    init?: RequestInit;
+};
+type PartialAuthorizer = null | {
+    state?: {
+        baseUrl?: string;
+        session?: {
+            user?: {
+                email?: string | undefined;
+            };
+        };
+    };
+    requestInit?: RequestInit | undefined;
+};
+
+type WarningCode = 'NEXTAUTH_URL' | 'NO_SECRET' | 'TWITTER_OAUTH_2_BETA' | 'DEBUG_ENABLED';
+/**
+ * Override any of the methods, and the rest will use the default logger.
+ *
+ * [Documentation](https://next-auth.js.org/configuration/options#logger)
+ */
+interface LoggerInstance extends Record<string, (...args: any) => any> {
+    warn: (code: WarningCode) => void;
+    error: (code: string, 
+    /**
+     * Either an instance of (JSON serializable) Error
+     * or an object that contains some debug information.
+     * (Error is still available through `metadata.error`)
+     */
+    metadata: Error | {
+        error: Error;
+        [key: string]: unknown;
+    }) => void;
+    debug: (code: string, metadata: unknown) => void;
+}
+
+type GetSessionParams = CtxOrReq & {
+    event?: 'storage' | 'timer' | 'hidden' | string;
+    triggerEvent?: boolean;
+    broadcast?: boolean;
+    baseUrl?: string;
+    init?: RequestInit;
+};
+declare enum State {
+    SESSION = "getSession"
+}
+declare class Authorizer {
+    state: AuthState;
+    logger: LoggerInstance;
+    requestInit?: RequestInit;
+    addListener: (cb: Listener) => void;
+    removeListener: (cb: Listener) => void;
+    status: null | State;
+    constructor(config?: AuthConfig);
+    sync(event?: 'storage' | 'timer' | 'hidden' | 'poll' | 'visibilitychange'): Promise<void>;
+    set baseUrl(val: string);
+    get baseUrl(): string;
+    configure(config?: Config): this;
+    sanitize(): PartialAuthorizer;
+    initialize(params?: {
+        baseUrl?: string;
+        session?: NonErrorSession | null | undefined;
+    }): Promise<void>;
+    get apiBaseUrl(): string;
+    fetchData<T = any>(url: string, init?: RequestInit): Promise<T | undefined>;
+    fetchFormData<T = {
+        url: string;
+    }>(url: string, init: RequestInit): Promise<{
+        data: T;
+        status: number;
+        ok: boolean;
+        url: string;
+    } | undefined>;
+    getProviders(): Promise<Record<LiteralUnion<BuiltInProviderType>, ClientSafeProvider> | undefined>;
+    getCsrfToken(): Promise<string | undefined>;
+    getSession(params?: GetSessionParams): Promise<NonErrorSession>;
+    refreshSession(): Promise<NonErrorSession>;
+    signOut<R extends boolean = true>(options?: SignOutParams<R> & {
+        baseUrl?: string;
+        auth?: Authorizer | PartialAuthorizer;
+        fetchUrl?: string;
+    }): Promise<R extends true ? undefined : SignOutResponse>;
+    signIn<P extends RedirectableProviderType | undefined = undefined>(provider?: LiteralUnion<P extends RedirectableProviderType ? P | BuiltInProviderType : BuiltInProviderType>, options?: SignInOptions & {
+        baseUrl?: string;
+        init?: ResponseInit;
+        fetchUrl?: string;
+        auth?: Authorizer | PartialAuthorizer;
+    }, authorizationParams?: SignInAuthorizationParams): Promise<P extends RedirectableProviderType ? SignInResponse | undefined : undefined>;
+    signUp(options: {
+        baseUrl?: string;
+        init?: ResponseInit;
+        fetchUrl?: string;
+        newTenantName?: string;
+        createTenant?: string | boolean;
+        email: string;
+        password: string;
+        auth?: Authorizer | PartialAuthorizer;
+        tenantId?: string;
+        callbackUrl?: string;
+        redirect?: boolean;
+    }): Promise<any>;
+}
+declare const authorizer: Authorizer;
+declare const auth: Authorizer;
+declare const getSession: (params?: GetSessionParams) => Promise<NonErrorSession>;
+declare const getCsrfToken: () => Promise<string | undefined>;
+declare const getProviders: () => Promise<Record<LiteralUnion<BuiltInProviderType>, ClientSafeProvider> | undefined>;
+declare const signOut: typeof authorizer.signOut;
+declare const signIn: typeof authorizer.signIn;
+
+type ComponentFetchProps = {
+    auth?: Authorizer | PartialAuthorizer;
+    init?: RequestInit;
+};
+type PrefetchParams = {
+    baseUrl?: string;
+    disableQuery?: boolean;
+    init?: RequestInit;
+    client?: QueryClient;
+    fetchUrl?: string;
+};
+
 type SignUpInfo = CreateBasicUserRequest & {
     tenantId?: string;
     fetchUrl?: string;
@@ -114,20 +288,20 @@ type SignUpInfo = CreateBasicUserRequest & {
     newTenantName?: string;
 };
 type AllowedAny$2 = any;
-interface Props$4 {
+type Props$3 = PrefetchParams & {
     onSuccess?: (response: Response, formValues: SignUpInfo) => void;
     onError?: (e: Error, info: SignUpInfo) => void;
     beforeMutate?: (data: AllowedAny$2) => AllowedAny$2;
     buttonText?: string;
-    client?: QueryClient;
     callbackUrl?: string;
-    baseUrl?: string;
     createTenant?: string | boolean;
-}
+    className?: string;
+    redirect?: boolean;
+};
 
-declare function SigningUp(props: Props$4): React__default.JSX.Element;
+declare function SigningUp({ className, ...props }: Props$3): React__default.JSX.Element;
 
-declare function useSignUp<T extends SignUpInfo>(params: Props$4, client?: QueryClient): _tanstack_react_query.UseMutateFunction<Response, Error, SignUpInfo, unknown>;
+declare function useSignUp<T extends SignUpInfo>(params: Props$3, client?: QueryClient): _tanstack_react_query.UseMutateFunction<any, Error, SignUpInfo, unknown>;
 
 type AllowedAny$1 = any;
 type LoginInfo = {
@@ -135,49 +309,75 @@ type LoginInfo = {
     password: string;
 };
 type LoginSuccess = (response: AllowedAny$1, formValues: LoginInfo, ...args: AllowedAny$1) => void;
-interface Props$3 {
+type Props$2 = ComponentFetchProps & {
     beforeMutate?: (data: AllowedAny$1) => AllowedAny$1;
     onSuccess?: LoginSuccess;
     onError?: (error: Error, data: AllowedAny$1) => void;
     callbackUrl?: string;
     client?: QueryClient;
-}
+    className?: string;
+    baseUrl?: string;
+    fetchUrl?: string;
+};
 
-declare function SigningIn(props: Props$3): React__default.JSX.Element;
+declare function SigningIn({ className, ...props }: Props$2): React__default.JSX.Element;
 
-declare function useSignIn(params?: Props$3): _tanstack_react_query.UseMutateFunction<next_auth_react.SignInResponse | undefined, Error, LoginInfo, any>;
+declare function useSignIn(params?: Props$2): _tanstack_react_query.UseMutateFunction<next_auth_react.SignInResponse | undefined, Error, LoginInfo, any>;
 
-declare const SignOutButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+declare const SignOutButton: React__default.ForwardRefExoticComponent<ButtonProps & ComponentFetchProps & {
     redirect?: boolean;
     callbackUrl?: string;
     buttonText?: string;
+    baseUrl?: string;
 } & React__default.RefAttributes<HTMLButtonElement>>;
 
-type UpdateSession = (data?: any) => Promise<Session | null>;
+interface SessionProviderProps {
+    children: React__default.ReactNode;
+    session?: NileSession;
+    baseUrl?: string;
+    basePath?: string;
+    /**
+     * A time interval (in seconds) after which the session will be re-fetched.
+     * If set to `0` (default), the session is not polled.
+     */
+    refetchInterval?: number;
+    /**
+     * `SessionProvider` automatically refetches the session when the user switches between windows.
+     * This option activates this behaviour if set to `true` (default).
+     */
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Set to `false` to stop polling when the device has no internet access offline (determined by `navigator.onLine`)
+     *
+     * [`navigator.onLine` documentation](https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine)
+     */
+    refetchWhenOffline?: false;
+}
+type UpdateSession = (data?: any) => Promise<NonErrorSession | null | undefined>;
 type SessionContextValue<R extends boolean = false> = R extends true ? {
     update: UpdateSession;
-    data: Session;
+    data: NonErrorSession;
     status: 'authenticated';
 } | {
     update: UpdateSession;
-    data: null;
+    data: null | undefined;
     status: 'loading';
 } : {
     update: UpdateSession;
-    data: Session;
+    data: NonErrorSession;
     status: 'authenticated';
 } | {
     update: UpdateSession;
-    data: null;
+    data: null | undefined;
     status: 'unauthenticated' | 'loading';
 };
 declare const SessionContext: React__default.Context<{
     update: UpdateSession;
-    data: Session;
+    data: NonErrorSession;
     status: "authenticated";
 } | {
     update: UpdateSession;
-    data: null;
+    data: null | undefined;
     status: "unauthenticated" | "loading";
 } | undefined>;
 /**
@@ -187,44 +387,12 @@ declare const SessionContext: React__default.Context<{
  * [Documentation](https://next-auth.js.org/getting-started/client#usesession)
  */
 declare function useSession<R extends boolean>(options?: UseSessionOptions<R>): SessionContextValue<R>;
-type GetSessionParams = CtxOrReq & {
-    event?: 'storage' | 'timer' | 'hidden' | string;
-    triggerEvent?: boolean;
-    broadcast?: boolean;
-};
-declare function getSession(params?: GetSessionParams): Promise<Session | null>;
-/**
- * Returns the current Cross Site Request Forgery Token (CSRF Token)
- * required to make POST requests (e.g. for signing in and signing out).
- * You likely only need to use this if you are not using the built-in
- * `signIn()` and `signOut()` methods.
- *
- * [Documentation](https://next-auth.js.org/getting-started/client#getcsrftoken)
- */
-declare function getCsrfToken(params?: CtxOrReq): Promise<string | undefined>;
-/**
- * It calls `/api/auth/providers` and returns
- * a list of the currently configured authentication providers.
- * It can be useful if you are creating a dynamic custom sign in page.
- *
- * [Documentation](https://next-auth.js.org/getting-started/client#getproviders)
- */
-declare function getProviders(): Promise<Record<LiteralUnion<BuiltInProviderType>, ClientSafeProvider> | null>;
-/**
- * Client-side method to initiate a signin flow
- * or send the user to the signin page listing all possible providers.
- * Automatically adds the CSRF token to the request.
- *
- * [Documentation](https://next-auth.js.org/getting-started/client#signin)
- */
-declare function signIn<P extends RedirectableProviderType | undefined = undefined>(provider?: LiteralUnion<P extends RedirectableProviderType ? P | BuiltInProviderType : BuiltInProviderType>, options?: SignInOptions, authorizationParams?: SignInAuthorizationParams): Promise<P extends RedirectableProviderType ? SignInResponse | undefined : undefined>;
 /**
  * Signs the user out, by removing the session cookie.
  * Automatically adds the CSRF token to the request.
  *
  * [Documentation](https://next-auth.js.org/getting-started/client#signout)
  */
-declare function signOut<R extends boolean = true>(options?: SignOutParams<R>): Promise<R extends true ? undefined : SignOutResponse>;
 /**
  * Provider to wrap the app in to make session data available globally.
  * Can also be used to throttle the number of requests to the endpoint
@@ -233,36 +401,12 @@ declare function signOut<R extends boolean = true>(options?: SignOutParams<R>):
  * [Documentation](https://next-auth.js.org/getting-started/client#sessionprovider)
  */
 declare function SessionProvider(props: SessionProviderProps): React__default.JSX.Element;
-type JWT = {
-    email: string;
-    sub: string;
-    id: string;
-    iat: number;
-    exp: number;
-    jti: string;
-};
-type ActiveSession = {
-    id: string;
-    email: string;
-    expires: string;
-    user?: {
-        id: string;
-        name: string;
-        image: string;
-        email: string;
-        emailVerified: void | Date;
-    };
-};
-type NonErrorSession = JWT | ActiveSession | null | undefined;
-type NileSession = Response | NonErrorSession;
 
-declare function SignedIn({ children, session: startSession, ...props }: Omit<SessionProviderProps, 'session'> & {
-    session?: NileSession;
+declare function SignedIn({ children, session: startSession, ...props }: SessionProviderProps & {
     className?: string;
 }): React__default.JSX.Element | null;
 
-declare function SignedOut({ children, session: startSession, ...props }: Omit<SessionProviderProps, 'session'> & {
-    session?: NileSession;
+declare function SignedOut({ children, session: startSession, ...props }: SessionProviderProps & {
     className?: string;
 }): React__default.JSX.Element | null;
 
@@ -271,23 +415,24 @@ type Tenant = {
     name: string;
 };
 
-type HookProps = {
+type HookProps$1 = ComponentFetchProps & {
+    fetchUrl?: string;
     tenants?: Tenant[];
     onError?: (e: Error) => void;
     baseUrl?: string;
 };
-type ComponentProps = HookProps & {
+type ComponentProps = HookProps$1 & {
     client?: QueryClient;
     activeTenant?: string;
     useCookie?: boolean;
     className?: string;
 };
 
-declare function useTenants(params: HookProps & {
+declare function useTenants(params: HookProps$1 & {
     disableQuery?: boolean;
 }, client?: QueryClient): _tanstack_react_query.UseQueryResult<Tenant[], Error>;
-declare function useTenantId(params?: HookProps & {
-    tenant: Tenant;
+declare function useTenantId(params?: HookProps$1 & {
+    tenant?: Tenant;
 }, client?: QueryClient): [string | undefined, (tenant: string) => void];
 
 declare function TenantSelector(props: ComponentProps): React__default.JSX.Element;
@@ -307,41 +452,36 @@ interface User {
     }[];
 }
 
-type Props$2 = {
-    fetchUrl?: string;
+type HookProps = ComponentFetchProps & {
     user?: User | undefined | null;
+    baseUrl?: string;
+    client?: QueryClient;
+    fetchUrl?: string;
 };
-declare function useMe(props: Props$2): User | null | undefined;
+declare function useMe(props: HookProps): any;
 
-type Props$1 = {
-    user?: User | undefined | null;
-    fetchUrl?: string;
+type Props$1 = HookProps & {
     profilePicturePlaceholder?: React__default.ReactElement;
     className?: string;
 };
-declare function UserInfo(props: Props$1): React__default.JSX.Element | "Loading...";
+declare function UserInfo(props: Props$1): React__default.JSX.Element;
 
-type Props = Params & {
-    client?: QueryClient;
-    callbackUrl?: string;
-    defaultValues?: MutateFnParams & {
-        confirmPassword?: string;
-    };
-};
 type AllowedAny = any;
-interface Params {
+type Params = PrefetchParams & {
     beforeMutate?: (data: AllowedAny) => AllowedAny;
     onSuccess?: (res: Response) => void;
     onError?: (error: Error, data: AllowedAny) => void;
     callbackUrl?: string;
-    client?: QueryClient;
-    fetchUrl?: string;
-    baseUrl?: string;
-}
+};
 type MutateFnParams = {
     email?: string;
     password?: string;
 };
+type Props = Params & {
+    defaultValues?: MutateFnParams & {
+        confirmPassword?: string;
+    };
+};
 
 declare function ResetPasswordForm$1(props: Props): React__default.JSX.Element;
 
@@ -352,4 +492,4 @@ declare function useResetPassword(params?: Params): _tanstack_react_query.UseMut
 declare const Email: () => React.JSX.Element;
 declare const Password: () => React.JSX.Element;
 
-export { AzureSignInButton as Azure, DiscordSignInButton as Discord, Email, EmailSigningIn as EmailSignIn, EmailSignInButton, GitHubSignInButton as GitHub, GoogleSSOButton as Google, HubSpotSignInButton as HubSpot, LinkedInSignInButton as LinkedIn, Password, ResetPasswordForm as PasswordResetForm, ResetPasswordForm$1 as PasswordResetRequestForm, SessionContext, SessionProvider, SigningIn as SignInForm, SignOutButton, SigningUp as SignUpForm, SignedIn, SignedOut, SlackSignInButton as Slack, TenantSelector, UserInfo, XSignInButton as X, getCsrfToken, getProviders, getSession, signIn, signOut, useEmailSignIn, useMe, useResetPassword, useSession, useSignIn, useSignUp, useTenantId, useTenants };
+export { type ActiveSession, type AuthConfig, type AuthState, Authorizer, AzureSignInButton as Azure, DiscordSignInButton as Discord, Email, EmailSigningIn as EmailSignIn, EmailSignInButton, GitHubSignInButton as GitHub, GoogleSSOButton as Google, HubSpotSignInButton as HubSpot, type JWT, LinkedInSignInButton as LinkedIn, type Listener, type ListenerKeys, type ListenerParams, Password, ResetPasswordForm as PasswordResetForm, ResetPasswordForm$1 as PasswordResetRequestForm, type NonErrorSession as Session, SessionContext, SessionProvider, SigningIn as SignInForm, SignOutButton, SigningUp as SignUpForm, SignedIn, SignedOut, SlackSignInButton as Slack, TenantSelector, UserInfo, XSignInButton as X, auth, getCsrfToken, getProviders, getSession, signIn, signOut, useEmailSignIn, useMe, useResetPassword, useSession, useSignIn, useSignUp, useTenantId, useTenants };