@ouim/logto-authkit 0.3.0

package/dist/bundler-config.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=(s="vite")=>{const t={jose:"jose/dist/node/cjs"};switch(s){case"vite":return{optimizeDeps:{include:["@logto/react"]},resolve:{alias:t}};case"webpack":case"nextjs":return{resolve:{alias:t}};default:return{alias:t}}},n=e("vite"),o=e("webpack"),i=e("nextjs");exports.getBundlerConfig=e;exports.nextjsConfig=i;exports.viteConfig=n;exports.webpackConfig=o;

package/dist/bundler-config.d.ts

@@ -0,0 +1,81 @@
+interface BundlerConfig {
+    optimizeDeps?: {
+        include: string[];
+    };
+    resolve?: {
+        alias: Record<string, string>;
+    };
+    alias?: Record<string, string>;
+}
+/**
+ * Bundler Configuration Helper
+ *
+ * Returns bundler-specific configuration to resolve the jose library correctly.
+ * The jose library has different import paths for different environments, and bundlers
+ * need proper configuration to handle these correctly.
+ *
+ * @param {'vite' | 'webpack' | 'nextjs'} [bundler='vite'] - Target bundler type
+ *
+ * @returns {BundlerConfig} Configuration object for the specified bundler
+ *
+ * @example
+ * // Vite configuration
+ * import { getBundlerConfig } from '@ouim/logto-authkit';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   ...getBundlerConfig('vite'),
+ *   // other vite config
+ * });
+ *
+ * @example
+ * // Webpack configuration
+ * import { getBundlerConfig } from '@ouim/logto-authkit';
+ *
+ * module.exports = {
+ *   ...getBundlerConfig('webpack'),
+ *   // other webpack config
+ * };
+ *
+ * @example
+ * // Next.js configuration
+ * const { getBundlerConfig } = require('@ouim/logto-authkit');
+ *
+ * module.exports = {
+ *   ...getBundlerConfig('nextjs'),
+ *   // other Next.js config
+ * };
+ */
+export declare const getBundlerConfig: (bundler?: "vite" | "webpack" | "nextjs") => BundlerConfig;
+/**
+ * Vite bundler configuration pre-built for Logto.
+ * Use this directly in your vite.config.ts if you don't need custom configuration.
+ *
+ * @example
+ * import { viteConfig } from '@ouim/logto-authkit';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({ ...viteConfig });
+ */
+export declare const viteConfig: BundlerConfig;
+/**
+ * Webpack bundler configuration pre-built for Logto.
+ * Use this directly in your webpack.config.js if you don't need custom configuration.
+ *
+ * @example
+ * const { webpackConfig } = require('@ouim/logto-authkit');
+ *
+ * module.exports = { ...webpackConfig, entry: './src/index.js' };
+ */
+export declare const webpackConfig: BundlerConfig;
+/**
+ * Next.js bundler configuration pre-built for Logto.
+ * Use this directly in your next.config.js if you don't need custom configuration.
+ *
+ * @example
+ * const { nextjsConfig } = require('@ouim/logto-authkit');
+ *
+ * module.exports = { ...nextjsConfig };
+ */
+export declare const nextjsConfig: BundlerConfig;
+export {};

package/dist/bundler-config.js

@@ -0,0 +1,31 @@
+const s = (t = "vite") => {
+  const e = {
+    jose: "jose/dist/node/cjs"
+  };
+  switch (t) {
+    case "vite":
+      return {
+        optimizeDeps: {
+          include: ["@logto/react"]
+        },
+        resolve: {
+          alias: e
+        }
+      };
+    case "webpack":
+    case "nextjs":
+      return {
+        resolve: {
+          alias: e
+        }
+      };
+    default:
+      return { alias: e };
+  }
+}, o = s("vite"), n = s("webpack"), i = s("nextjs");
+export {
+  s as getBundlerConfig,
+  i as nextjsConfig,
+  o as viteConfig,
+  n as webpackConfig
+};

package/dist/callback.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { CallbackPageProps } from './types.js';
+export declare const CallbackPage: React.FC<CallbackPageProps>;

package/dist/components/signin-button.d.ts

@@ -0,0 +1,53 @@
+import type { ButtonProps } from './ui/button.js';
+export interface SignInButtonProps extends Omit<ButtonProps, 'onClick'> {
+    /**
+     * The text label displayed on the button.
+     * @default "Sign In"
+     */
+    label?: string;
+    /**
+     * The URL to redirect to after successful sign-in.
+     * If not provided, defaults to the AuthProvider's callbackUrl.
+     */
+    redirectUri?: string;
+    /**
+     * Whether to use popup sign-in flow instead of redirect.
+     * If not provided, defaults to the AuthProvider's enablePopupSignIn setting.
+     */
+    usePopup?: boolean;
+    /**
+     * Optional callback to execute before initiating sign-in.
+     * Useful for tracking or validation.
+     */
+    onBeforeSignIn?: () => void | Promise<void>;
+    /**
+     * Optional callback to execute after sign-in completes.
+     * Useful for tracking or post-sign-in logic.
+     */
+    onAfterSignIn?: () => void | Promise<void>;
+    /**
+     * Optional callback to execute if sign-in fails.
+     */
+    onSignInError?: (error: Error) => void;
+}
+/**
+ * A simple, reusable button component for initiating the sign-in flow.
+ *
+ * @example
+ * // Basic usage with default settings
+ * <SignInButton />
+ *
+ * @example
+ * // With custom props
+ * <SignInButton
+ *   label="Log in to your account"
+ *   usePopup={true}
+ *   variant="outline"
+ *   onAfterSignIn={() => console.log('User signed in!')}
+ * />
+ *
+ * @example
+ * // With custom redirect
+ * <SignInButton redirectUri="/dashboard" />
+ */
+export declare function SignInButton({ label, redirectUri, usePopup, onBeforeSignIn, onAfterSignIn, onSignInError, disabled, ...buttonProps }: SignInButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/components/ui/card.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuRadioGroup, };

package/dist/components/ui/loading-spinner.d.ts

@@ -0,0 +1,2 @@
+declare const LoadingSpinner: () => import("react/jsx-runtime").JSX.Element;
+export default LoadingSpinner;

package/dist/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/utils/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/context.d.ts

@@ -0,0 +1,57 @@
+import type { AuthContextType, AuthProviderProps } from './types.js';
+/**
+ * AuthProvider Component
+ *
+ * Main authentication provider that wraps your application with Logto authentication.
+ * Sets up authentication context, handles sign-in/sign-out flows, and manages auth state.
+ *
+ * @component
+ * @param {React.ReactNode} children - React components to wrap with authentication context
+ * @param {LogtoConfig} config - Logto configuration object containing endpoint, appId, and resources
+ * @param {string} [callbackUrl] - Default URL to redirect to after authentication (e.g., '/dashboard'). Can be overridden per sign-in call
+ * @param {Function} [customNavigate] - Custom navigation function for client-side routing (e.g., from React Router or Next.js). If not provided, uses window.location
+ * @param {boolean} [enablePopupSignIn=false] - Enable popup-based sign-in flow (opens sign-in in a new window). Defaults to redirect flow
+ * @param {(event: AuthTokenRefreshEvent) => void} [onTokenRefresh] - Called when an existing authenticated session receives a different access token
+ * @param {(event: AuthErrorEvent) => void} [onAuthError] - Called when auth loading hits a transient or definitive auth error
+ * @param {(event: AuthSignOutEvent) => void} [onSignOut] - Called immediately before the provider initiates local or global sign-out
+ *
+ * @example
+ * // Basic setup with Logto configuration
+ * <AuthProvider config={{ endpoint: 'https://tenant.logto.app', appId: 'app_id_here', resources: { api: 'urn:logto:resource:api' } }}>
+ *   <App />
+ * </AuthProvider>
+ *
+ * @example
+ * // With custom React Router navigation
+ * import { useNavigate } from 'react-router-dom'
+ *
+ * function AuthProviderWrapper({ children }) {
+ *   const navigate = useNavigate()
+ *   return (
+ *     <AuthProvider
+ *       config={logtoConfig}
+ *       callbackUrl="/dashboard"
+ *       enablePopupSignIn={true}
+ *       customNavigate={(url) => navigate(url)}
+ *     >
+ *       {children}
+ *     </AuthProvider>
+ *   )
+ * }
+ *
+ * @throws {Error} If required Logto configuration is missing or invalid (endpoint, appId)
+ */
+export declare const AuthProvider: ({ children, config, callbackUrl, customNavigate, enablePopupSignIn, onTokenRefresh, onAuthError, onSignOut, }: AuthProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * useAuthContext Hook (Internal)
+ *
+ * Internal hook to access the authentication context. Not exported directly.
+ * Use the exported {@link useAuth} hook instead for the public API.
+ *
+ * @internal
+ * @returns {AuthContextType} Authentication context with user, loading state, and auth functions
+ * @throws {Error} If used outside of AuthProvider context
+ *
+ * @see {@link useAuth} for the public API to access auth context
+ */
+export declare const useAuthContext: () => AuthContextType;