@openfort/react 0.0.1

package/build/hooks/openfort/useProviders.d.ts

@@ -0,0 +1,6 @@
+import { AuthProvider } from "../../components/OpenfortKit/types";
+export declare function useProviders(): {
+    availableProviders: AuthProvider[];
+    linkedProviders: AuthProvider[];
+    allProviders: AuthProvider[];
+};

package/build/hooks/openfort/useStatus.d.ts

@@ -0,0 +1,16 @@
+export declare enum OpenfortKitStatus {
+    LOADING = 0,
+    CONNECTED = 1,
+    DISCONNECTED = 2,
+    NEEDS_RECOVERY = 3,
+    CONNECTED_WITHOUT_USER = 4
+}
+export declare function useStatus(): {
+    status: OpenfortKitStatus;
+    isLoading: boolean;
+    hasUser: boolean;
+    isConnected: boolean;
+    isDisconnected: boolean;
+    isConnectedWithoutUser: boolean;
+    needsRecovery: boolean;
+};

package/build/hooks/openfort/useUI.d.ts

@@ -0,0 +1,10 @@
+export declare function useUI(): {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    setIsOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    openProfile: () => void;
+    openSwitchNetworks: () => void;
+    openProviders: () => void;
+    openWallets: () => void;
+};

package/build/hooks/openfort/useUser.d.ts

@@ -0,0 +1,5 @@
+export declare function useUser(): {
+    user: import("@openfort/openfort-js").AuthPlayerResponse | null;
+    getAccessToken: () => Promise<string | null>;
+    validateAndRefreshToken: () => Promise<void>;
+};

package/build/hooks/openfort/useWallets.d.ts

@@ -0,0 +1,37 @@
+import { Connector } from "wagmi";
+import { embeddedWalletId } from "../../constants/openfort";
+import { Hex } from "viem";
+import { OpenfortKitError } from "../../types";
+export type UserWallet = {
+    address?: `0x${string}`;
+    connectorType?: string;
+    walletClientType?: string;
+    connector?: Connector;
+    id: string;
+    isAvailable: boolean;
+    isActive: boolean;
+};
+type SetActiveWalletOptions = {
+    showUI?: boolean;
+    address?: Hex | undefined;
+} & ({
+    connector: string;
+} | {
+    connector: typeof embeddedWalletId;
+    password?: string;
+});
+export declare function useWallets(): {
+    exportPrivateKey: () => Promise<string>;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: OpenfortKitError | null | undefined;
+    wallets: UserWallet[];
+    availableWallets: import("../../wallets/useWallets").WalletProps[];
+    activeWallet: UserWallet | undefined;
+    setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<{
+        error?: string;
+        wallet?: UserWallet;
+    }>;
+};
+export {};

package/build/hooks/useChainIsSupported.d.ts

@@ -0,0 +1 @@
+export declare function useChainIsSupported(chainId?: number): boolean | null;

package/build/hooks/useChains.d.ts

@@ -0,0 +1,2 @@
+import { Chain } from 'viem';
+export declare function useChains(): Chain[];

package/build/hooks/useConnect.d.ts

@@ -0,0 +1,110 @@
+/**
+ * This is a wrapper around wagmi's useConnect hook that adds some
+ * additional functionality.
+ */
+import { Connector, CreateConnectorFn, type UseConnectParameters } from 'wagmi';
+export declare function useConnect({ ...props }?: UseConnectParameters): {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    data: undefined;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    data: undefined;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    error: import("@wagmi/core").ConnectErrorType;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+} | {
+    data: import("wagmi/query").ConnectData<import("wagmi").Config>;
+    variables: import("wagmi/query").ConnectVariables<import("wagmi").Config, Connector<CreateConnectorFn>>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: import("@wagmi/core").ConnectErrorType | null;
+    isPaused: boolean;
+    submittedAt: number;
+    connect: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => void;
+    connectAsync: ({ connector, chainId, mutation, }: {
+        connector: CreateConnectorFn | Connector;
+        chainId?: number;
+        mutation?: UseConnectParameters["mutation"];
+    }) => Promise<import("wagmi/query").ConnectData<import("wagmi").Config>>;
+    connectors: readonly Connector<CreateConnectorFn>[];
+};

package/build/hooks/useConnectCallback.d.ts

@@ -0,0 +1,10 @@
+import { AuthPlayerResponse } from '@openfort/openfort-js';
+export type useConnectCallbackProps = {
+    onConnect?: ({ address, connectorId, user, }: {
+        address?: string;
+        connectorId?: string;
+        user?: AuthPlayerResponse;
+    }) => void;
+    onDisconnect?: () => void;
+};
+export declare const useConnectCallback: ({ onConnect, onDisconnect, }: useConnectCallbackProps) => void;

package/build/hooks/useConnectors.d.ts

@@ -0,0 +1,7 @@
+import { type Connector } from 'wagmi';
+export declare function useConnectors(): readonly Connector<import("wagmi").CreateConnectorFn>[];
+export declare function useConnector(id: string, uuid?: string): Connector;
+export declare function useInjectedConnector(uuid?: string): Connector;
+export declare function useWalletConnectConnector(): Connector;
+export declare function useCoinbaseWalletConnector(): Connector;
+export declare function useMetaMaskConnector(): Connector;

package/build/hooks/useEnsFallbackConfig.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '@wagmi/core';
+export declare function useEnsFallbackConfig(): Config | undefined;

package/build/hooks/useFitText.d.ts

@@ -0,0 +1,14 @@
+export type TLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+export type TOptions = {
+    logLevel?: TLogLevel;
+    maxFontSize?: number;
+    minFontSize?: number;
+    onFinish?: (fontSize: number) => void;
+    onStart?: () => void;
+    resolution?: number;
+};
+declare const useFitText: ({ logLevel: logLevelOption, maxFontSize, minFontSize, onFinish, onStart, resolution, }?: TOptions) => {
+    fontSize: number;
+    ref: import("react").RefObject<HTMLDivElement>;
+};
+export default useFitText;

package/build/hooks/useFocusTrap.d.ts

@@ -0,0 +1 @@
+export default function FocusTrap(props: any): import("react/jsx-runtime").JSX.Element;

package/build/hooks/useGoogleFont.d.ts

@@ -0,0 +1,3 @@
+import { Theme } from '../types';
+export declare function useGoogleFont(font: string): void;
+export declare function useThemeFont(theme: Theme): void;

package/build/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export default function useIsMobile(): boolean;

package/build/hooks/useIsMounted.d.ts

@@ -0,0 +1 @@
+export default function useIsMounted(): boolean;

package/build/hooks/useLastConnector.d.ts

@@ -0,0 +1,4 @@
+export declare const useLastConnector: () => {
+    lastConnectorId: string | null;
+    updateLastConnectorId: (id: string) => void;
+};

package/build/hooks/useLocalStorage.d.ts

@@ -0,0 +1,7 @@
+export declare const useLocalStorage: (storageKey: string) => {
+    data: any;
+    add: (item: any) => void;
+    remove: (item: any) => void;
+    update: (items: any) => void;
+    clear: () => void;
+};

package/build/hooks/useLocales.d.ts

@@ -0,0 +1 @@
+export default function useLocales(replacements?: any): any;

package/build/hooks/useLockBodyScroll.d.ts

@@ -0,0 +1 @@
+export default function useLockBodyScroll(initialLocked: boolean): (boolean | import("react").Dispatch<import("react").SetStateAction<boolean>>)[];

package/build/hooks/usePrevious.d.ts

@@ -0,0 +1 @@
+export default function usePrevious(value: any, initial?: any): any;

package/build/hooks/useWalletConnectModal.d.ts

@@ -0,0 +1,4 @@
+export declare function useWalletConnectModal(): {
+    isOpen: boolean;
+    open: () => Promise<void>;
+};

package/build/hooks/useWindowSize.d.ts

@@ -0,0 +1,4 @@
+export default function useWindowSize(): {
+    width: number;
+    height: number;
+};

package/build/index.d.ts

@@ -0,0 +1,27 @@
+export { OPENFORTKIT_VERSION } from './version';
+export * from './types';
+export { default as getDefaultConfig } from './defaultConfig';
+export { default as getDefaultConnectors } from './defaultConnectors';
+export { wallets } from './wallets';
+export { AuthProvider, } from './components/OpenfortKit/types';
+export { OpenfortKitContext, } from './components/OpenfortKit/context';
+export { OpenfortKitProvider, } from './components/OpenfortKit/OpenfortKit';
+export { OpenfortKitButton } from './components/ConnectButton';
+export { default as Avatar } from './components/Common/Avatar';
+export { default as ChainIcon } from './components/Common/Chain';
+export { useChains } from './hooks/useChains';
+export { useChainIsSupported } from './hooks/useChainIsSupported';
+export { useStatus, OpenfortKitStatus } from './hooks/openfort/useStatus';
+export { useUser } from './hooks/openfort/useUser';
+export { useUI } from "./hooks/openfort/useUI";
+export { useWallets, UserWallet } from "./hooks/openfort/useWallets";
+export { RecoveryMethod, AuthPlayerResponse } from "@openfort/openfort-js";
+export { useOpenfort } from './openfort/useOpenfort';
+export { useConnectWithSiwe } from './hooks/openfort/useConnectWithSiwe';
+export { embeddedWalletId } from './constants/openfort';
+export { useEmailAuth } from './hooks/openfort/auth/useEmailAuth';
+export { useAuthCallback } from './hooks/openfort/auth/useAuthCallback';
+export { useGuestAuth } from './hooks/openfort/auth/useGuestAuth';
+export { useWalletAuth } from './hooks/openfort/auth/useWalletAuth';
+export { useOAuth } from './hooks/openfort/auth/useOAuth';
+export { useSignOut } from './hooks/openfort/auth/useSignOut';