@hexdspace/react 0.0.12 → 0.0.13

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient, QueryKey } from '@tanstack/react-query';
-import { ResultOk, ResultError } from '@hexdspace/util';
-import React, { CSSProperties } from 'react';
+import { ResultOk, ResultError, AsyncResult, Result } from '@hexdspace/util';
+import * as react from 'react';
+import react__default, { CSSProperties, Dispatch, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type NotificationVariant = 'success' | 'warning' | 'error' | 'info';
 declare const DEFAULT_NOTIFICATION_CHANNEL = "app.notifications";
@@ -118,7 +120,7 @@ type NotificationHostProps = {
     isDark?: () => boolean;
     theme?: ToastTheme;
 };
-declare const NotificationHost: React.FC<NotificationHostProps>;
+declare const NotificationHost: react__default.FC<NotificationHostProps>;
 
 type InstructionContext = {
     queryClient: QueryClient;
@@ -163,4 +165,214 @@ type ResponsiveMutation<Args, Res> = {
 
 declare function useResponsiveMutation<Args, Res>(responsiveMutation: ResponsiveMutation<Args, Res>, queryClient: QueryClient): _tanstack_react_query.UseMutationResult<UIOk<Res>, UIFail, Args, OptimisticSnapshot | undefined>;
 
-export { type CacheInstruction, type CustomInstruction, DEFAULT_NOTIFICATION_CHANNEL, type Instruction, type InstructionContext, type Notification, type NotificationAction, NotificationHost, type NotificationInstruction, type NotificationVariant, NotifierController, type OptimisticSnapshot, type ResolvedToastTheme, type ResponsiveMutation, type ToastActionTheme, type ToastTheme, type ToastTransition, type ToastifyCSSVars, type UIFail, type UIOk, type UIResult, notifierController, resolveToastTheme, ui, useResponsiveMutation };
+type FactoryBuilder<TDeps, TController> = (deps: TDeps) => TController;
+type FactoryDefaults<TDeps> = (overrides: Partial<TDeps>) => TDeps;
+declare function controllerFactory<TDeps, TController>(builder: FactoryBuilder<TDeps, TController>, defaults: FactoryDefaults<TDeps>): (overrides?: Partial<TDeps>) => TController;
+
+interface GenericResponse {
+    message: string;
+}
+
+interface ErrorResponse {
+    error: string;
+    details?: unknown;
+}
+
+interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}
+
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly response: ErrorResponse;
+    constructor(message: string, status: number, response: ErrorResponse);
+}
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+interface HttpClient {
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+}
+interface RequestConfig {
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+
+declare class AutoRefreshDecorator implements HttpClient {
+    private readonly httpClient;
+    private readonly refresh;
+    private static inFlightRefresh;
+    constructor(httpClient: HttpClient, refresh: (client: HttpClient) => AsyncResult<HttpError, GenericResponse>);
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    private tryRequest;
+    private needsRefresh;
+    private performRefresh;
+}
+
+declare const httpClient: AutoRefreshDecorator;
+
+type MockHandler<T = unknown> = (payload: {
+    url: string;
+    data?: unknown;
+    config?: RequestConfig;
+}) => Promise<HttpResponse<T>> | HttpResponse<T>;
+declare class MockHttpClient implements HttpClient {
+    private handlers;
+    register<T>(method: HttpMethod, url: string, handler: MockHandler<T>): void;
+    respondWith<T>(method: HttpMethod, url: string, response: HttpResponse<T>): void;
+    respondWithError(method: HttpMethod, url: string, error: Error): void;
+    reset(): void;
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    private invoke;
+}
+
+interface User {
+    id: string;
+    email: string;
+}
+
+interface LoginUser {
+    execute(email: string, password: string): AsyncResult<Error, User>;
+}
+
+interface LogoutUser {
+    execute(): AsyncResult<Error, null>;
+}
+
+interface RegisterUser {
+    execute(email: string, password: string): AsyncResult<Error, GenericResponse>;
+}
+
+interface GetAuthenticatedUser {
+    execute(): AsyncResult<Error, User | null>;
+}
+
+interface AuthProvider$1 {
+    getAuthenticatedUser(): AsyncResult<Error, User | null>;
+    login(email: string, password: string): AsyncResult<Error, User>;
+    register(email: string, password: string): AsyncResult<Error, GenericResponse>;
+    logout(): AsyncResult<Error, null>;
+}
+
+declare class AuthController {
+    private readonly loginUser;
+    private readonly logoutUser;
+    private readonly registerUser;
+    private readonly getAuthenticatedUser;
+    constructor(loginUser: LoginUser, logoutUser: LogoutUser, registerUser: RegisterUser, getAuthenticatedUser: GetAuthenticatedUser);
+    login(email: string, password: string): AsyncResult<Error, User>;
+    logout(): AsyncResult<Error, null>;
+    register(email: string, password: string): AsyncResult<Error, {
+        message: string;
+    }>;
+    getCurrentUser(): AsyncResult<Error, User | null>;
+}
+type AuthControllerDeps = {
+    httpClient: HttpClient;
+    authProvider: AuthProvider$1;
+    loginUser: LoginUser;
+    logoutUser: LogoutUser;
+    registerUser: RegisterUser;
+    getAuthenticatedUser: GetAuthenticatedUser;
+};
+declare const createAuthController: (overrides?: Partial<AuthControllerDeps>) => AuthController;
+declare const authController: AuthController;
+
+type AuthState = {
+    status: 'loading';
+} | {
+    status: 'authenticated';
+    user: User;
+} | {
+    status: 'unauthenticated';
+    message?: string;
+} | {
+    status: 'error';
+    error: string;
+};
+
+declare function useAuth(): AuthState;
+
+declare function useAuthActions(): {
+    login: (email: string, password: string) => void;
+    logout: () => void;
+    register: (email: string, password: string) => Promise<Result<Error, {
+        message: string;
+    }>>;
+};
+
+declare function useAuthedUser(): User;
+
+declare function useAuthController(): AuthController;
+
+type AuthAction = {
+    type: 'REQUEST';
+} | {
+    type: 'COMPLETE';
+    user: User;
+} | {
+    type: 'SUCCESS';
+    message: string;
+} | {
+    type: 'FAILED';
+    error: string;
+} | {
+    type: 'LOGOUT';
+};
+
+declare function useAuthDispatch(): Dispatch<AuthAction>;
+
+declare const AuthStateCtx: react.Context<AuthState | null>;
+declare const AuthDispatchCtx: react.Context<Dispatch<AuthAction> | null>;
+declare function AuthProvider({ children }: {
+    readonly children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const AuthControllerCtx: react.Context<AuthController | null>;
+type AuthControllerProviderProps = {
+    readonly children: ReactNode;
+    readonly controller: AuthController;
+};
+declare function AuthControllerProvider({ children, controller }: AuthControllerProviderProps): react_jsx_runtime.JSX.Element;
+
+interface InputProps {
+    id: string;
+    label: string;
+    type: string;
+    value: string;
+    onChange: (e: react__default.ChangeEvent<HTMLInputElement>) => void;
+    placeholder: string;
+    className?: string;
+}
+declare const AuthFormInputField: react__default.FC<InputProps>;
+
+type AuthFixtures = {
+    meError?: HttpError;
+    loginError?: HttpError;
+    registerError?: HttpError;
+    logoutError?: Error;
+    currentUser?: User | null;
+};
+declare class MockAuthHttpClient extends MockHttpClient {
+    private fixtures;
+    private readonly delayMs;
+    constructor(initial?: AuthFixtures, delayMs?: number);
+    setCurrentUser(user: User | null): void;
+    setLoginError(error: HttpError | undefined): void;
+    setRegisterError(error: HttpError | undefined): void;
+    setMeError(error: HttpError | undefined): void;
+    setLogoutError(error: Error | undefined): void;
+    private registerAuthRoutes;
+}
+
+export { AuthController, AuthControllerCtx, type AuthControllerDeps, AuthControllerProvider, AuthDispatchCtx, AuthFormInputField, AuthProvider, type AuthState, AuthStateCtx, type CacheInstruction, type CustomInstruction, DEFAULT_NOTIFICATION_CHANNEL, type ErrorResponse, type GenericResponse, HttpError, type HttpResponse, type Instruction, type InstructionContext, MockAuthHttpClient, MockHttpClient, type Notification, type NotificationAction, NotificationHost, type NotificationInstruction, type NotificationVariant, NotifierController, type OptimisticSnapshot, type ResolvedToastTheme, type ResponsiveMutation, type ToastActionTheme, type ToastTheme, type ToastTransition, type ToastifyCSSVars, type UIFail, type UIOk, type UIResult, type User, authController, controllerFactory, createAuthController, httpClient as fetchHttpClient, notifierController, resolveToastTheme, ui, useAuth, useAuthActions, useAuthController, useAuthDispatch, useAuthedUser, useResponsiveMutation };

package/dist/index.js

@@ -426,12 +426,597 @@ var executeEffects = (effects, ctx) => {
     }
   });
 };
+
+// src/util/controller-factory.ts
+function controllerFactory(builder, defaults) {
+  return (overrides = {}) => {
+    const resolvedDeps = defaults(overrides);
+    return builder({ ...resolvedDeps, ...overrides });
+  };
+}
+
+// src/feature/http/entity/http-error.ts
+var HttpError = class extends Error {
+  constructor(message, status, response) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.name = "HttpError";
+  }
+};
+
+// src/feature/http/infra/fetch-http-client.ts
+import { nok, ok } from "@hexdspace/util";
+
+// src/feature/http/infra/auto-refresh-decorator.ts
+var AutoRefreshDecorator = class _AutoRefreshDecorator {
+  constructor(httpClient2, refresh2) {
+    this.httpClient = httpClient2;
+    this.refresh = refresh2;
+  }
+  static inFlightRefresh = null;
+  async get(url, config) {
+    return this.tryRequest(() => this.httpClient.get(url, config));
+  }
+  async post(url, data, config) {
+    return this.tryRequest(() => this.httpClient.post(url, data, config));
+  }
+  async put(url, data, config) {
+    return this.tryRequest(() => this.httpClient.put(url, data, config));
+  }
+  async delete(url, config) {
+    return this.tryRequest(() => this.httpClient.delete(url, config));
+  }
+  async tryRequest(fn) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof HttpError && this.needsRefresh(e.status)) {
+        await this.performRefresh();
+        return fn();
+      }
+      throw e;
+    }
+  }
+  needsRefresh(status) {
+    return [401, 403, 419, 440].includes(status);
+  }
+  async performRefresh() {
+    if (_AutoRefreshDecorator.inFlightRefresh) {
+      return _AutoRefreshDecorator.inFlightRefresh;
+    }
+    _AutoRefreshDecorator.inFlightRefresh = (async () => {
+      const res = await this.refresh(this.httpClient);
+      if (!res.ok) {
+        throw new HttpError("Token refresh failed", res.error.status, res.error.response);
+      }
+    })().finally(() => {
+      _AutoRefreshDecorator.inFlightRefresh = null;
+    });
+    return _AutoRefreshDecorator.inFlightRefresh;
+  }
+};
+
+// src/feature/http/infra/fetch-http-client.ts
+var FetchHttpClient = class {
+  baseURL;
+  constructor(baseURL = "/api") {
+    this.baseURL = baseURL;
+  }
+  async get(url, config) {
+    return this.doRequest("GET", url, void 0, config);
+  }
+  async post(url, data, config) {
+    return this.doRequest("POST", url, data, config);
+  }
+  async put(url, data, config) {
+    return this.doRequest("PUT", url, data, config);
+  }
+  async delete(url, config) {
+    return this.doRequest("DELETE", url, void 0, config);
+  }
+  async doRequest(method, url, body, config) {
+    const isFormData = body instanceof FormData;
+    const headers = { ...config?.headers };
+    let parsedBody;
+    if (body !== void 0) {
+      parsedBody = isFormData ? body : JSON.stringify(body);
+    }
+    if (!isFormData) {
+      headers["Content-Type"] ??= "application/json";
+    }
+    try {
+      const res = await fetch(this.resolve(url), {
+        method,
+        body: parsedBody,
+        headers: { ...headers, ...config?.headers },
+        credentials: "include",
+        signal: config?.signal
+      });
+      const data = await (res.headers.get("content-type")?.includes("application/json") ? res.json() : res.text());
+      if (!res.ok) throw new HttpError(res.statusText, res.status, data);
+      return {
+        data,
+        status: res.status,
+        headers: Object.fromEntries(res.headers.entries())
+      };
+    } catch (err) {
+      if (err instanceof HttpError) throw err;
+      const message = err instanceof Error ? err.message : "HTTP request failed";
+      throw new HttpError(message, 0, { error: JSON.stringify(err) });
+    }
+  }
+  resolve(url) {
+    return url.startsWith("http") ? url : `${this.baseURL}${url}`;
+  }
+};
+async function refresh(httpClient2) {
+  try {
+    const res = await httpClient2.get("/auth/refresh");
+    return ok(res.data);
+  } catch (err) {
+    if (err instanceof HttpError) {
+      return nok(err);
+    } else {
+      return nok(new HttpError("Unknown error during refresh", 0, { error: JSON.stringify(err) }));
+    }
+  }
+}
+var httpClient = new AutoRefreshDecorator(new FetchHttpClient(), refresh);
+
+// src/feature/http/infra/mock-http-client.ts
+function getKey(method, url) {
+  return `${method}:${url}`;
+}
+var MockHttpClient = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(method, url, handler) {
+    this.handlers.set(getKey(method, url), handler);
+  }
+  respondWith(method, url, response) {
+    this.register(method, url, () => response);
+  }
+  respondWithError(method, url, error) {
+    this.register(method, url, () => Promise.reject(error));
+  }
+  reset() {
+    this.handlers.clear();
+  }
+  get(url, config) {
+    return this.invoke("GET", url, void 0, config);
+  }
+  post(url, data, config) {
+    return this.invoke("POST", url, data, config);
+  }
+  put(url, data, config) {
+    return this.invoke("PUT", url, data, config);
+  }
+  delete(url, config) {
+    return this.invoke("DELETE", url, void 0, config);
+  }
+  invoke(method, url, data, config) {
+    const handler = this.handlers.get(getKey(method, url));
+    if (!handler) {
+      return Promise.reject(new Error(`No mock handler registered for ${method} ${url}`));
+    }
+    const result = handler({ url, data, config });
+    return Promise.resolve(result);
+  }
+};
+
+// src/feature/auth/infra/http-cookie-auth-provider.ts
+import { nok as nok2, ok as ok2 } from "@hexdspace/util";
+var HttpCookieAuthProvider = class {
+  constructor(httpClient2) {
+    this.httpClient = httpClient2;
+  }
+  async getAuthenticatedUser() {
+    try {
+      const response = await this.httpClient.get("/auth/me");
+      return ok2(response.data.user);
+    } catch (err) {
+      if (isUnauthorizedError(err)) {
+        return ok2(null);
+      } else if (err instanceof Error) {
+        return nok2(err);
+      } else {
+        return nok2(new Error("Unknown error during authentication"));
+      }
+    }
+  }
+  async login(email, password) {
+    try {
+      const body = { email, password };
+      await this.httpClient.post("/auth/login", body);
+      const userResponse = await this.httpClient.get("/auth/me");
+      return ok2(userResponse.data.user);
+    } catch (err) {
+      if (err instanceof Error) {
+        return nok2(err);
+      } else {
+        return nok2(new Error("Unknown error during authentication"));
+      }
+    }
+  }
+  async register(email, password) {
+    try {
+      const res = await this.httpClient.post("/auth/register", { email, password });
+      return ok2(res.data);
+    } catch (err) {
+      if (err instanceof Error) {
+        return nok2(err);
+      } else {
+        return nok2(new Error("Unknown error during authentication"));
+      }
+    }
+  }
+  async logout() {
+    try {
+      await this.httpClient.post("/auth/logout");
+      return ok2(null);
+    } catch (err) {
+      if (err instanceof Error) {
+        return nok2(err);
+      } else {
+        return nok2(new Error("Unknown error during logout"));
+      }
+    }
+  }
+};
+function isUnauthorizedError(error) {
+  return error instanceof HttpError && error.status === 401;
+}
+
+// src/feature/auth/application/use-case/login-user-use-case.ts
+var LoginUserUseCase = class {
+  constructor(authProvider) {
+    this.authProvider = authProvider;
+  }
+  execute(email, password) {
+    return this.authProvider.login(email, password);
+  }
+};
+
+// src/feature/auth/application/use-case/logout-user-use-case.ts
+var LogoutUserUseCase = class {
+  constructor(authProvider) {
+    this.authProvider = authProvider;
+  }
+  execute() {
+    return this.authProvider.logout();
+  }
+};
+
+// src/feature/auth/application/use-case/register-user-use-case.ts
+var RegisterUserUseCase = class {
+  constructor(authProvider) {
+    this.authProvider = authProvider;
+  }
+  execute(email, password) {
+    return this.authProvider.register(email, password);
+  }
+};
+
+// src/feature/auth/application/use-case/get-authenticated-user-use-case.ts
+var GetAuthenticatedUserUseCase = class {
+  constructor(authProvider) {
+    this.authProvider = authProvider;
+  }
+  execute() {
+    return this.authProvider.getAuthenticatedUser();
+  }
+};
+
+// src/feature/auth/interface/controller/auth-controller.ts
+var AuthController = class {
+  constructor(loginUser, logoutUser, registerUser, getAuthenticatedUser) {
+    this.loginUser = loginUser;
+    this.logoutUser = logoutUser;
+    this.registerUser = registerUser;
+    this.getAuthenticatedUser = getAuthenticatedUser;
+  }
+  async login(email, password) {
+    return this.loginUser.execute(email, password);
+  }
+  async logout() {
+    return this.logoutUser.execute();
+  }
+  async register(email, password) {
+    return this.registerUser.execute(email, password);
+  }
+  async getCurrentUser() {
+    return this.getAuthenticatedUser.execute();
+  }
+};
+var createAuthController = controllerFactory(
+  (deps) => new AuthController(
+    deps.loginUser,
+    deps.logoutUser,
+    deps.registerUser,
+    deps.getAuthenticatedUser
+  ),
+  (overrides) => {
+    const httpClient2 = overrides.httpClient ?? httpClient;
+    const authProvider = overrides.authProvider ?? new HttpCookieAuthProvider(httpClient2);
+    return {
+      httpClient: httpClient2,
+      authProvider,
+      loginUser: overrides.loginUser ?? new LoginUserUseCase(authProvider),
+      logoutUser: overrides.logoutUser ?? new LogoutUserUseCase(authProvider),
+      registerUser: overrides.registerUser ?? new RegisterUserUseCase(authProvider),
+      getAuthenticatedUser: overrides.getAuthenticatedUser ?? new GetAuthenticatedUserUseCase(authProvider)
+    };
+  }
+);
+var authController = createAuthController();
+
+// src/feature/auth/interface/web/react/hook/useAuth.tsx
+import { useContext as useContext2 } from "react";
+
+// src/feature/auth/interface/web/react/AuthProvider.tsx
+import { createContext as createContext2, useEffect as useEffect2, useReducer } from "react";
+
+// src/feature/auth/interface/web/react/state/auth-reducer.ts
+function authStateReducer(_state, action) {
+  switch (action.type) {
+    case "REQUEST":
+      return { status: "loading" };
+    case "SUCCESS":
+      return { status: "unauthenticated", message: action.message };
+    case "FAILED":
+      return { status: "error", error: action.error };
+    case "LOGOUT":
+      return { status: "unauthenticated" };
+    case "COMPLETE":
+      return { status: "authenticated", user: action.user };
+    default:
+      throw new Error(`Unknown state: ${JSON.stringify(action)}`);
+  }
+}
+
+// src/feature/auth/interface/web/react/hook/useAuthController.tsx
+import { useContext } from "react";
+
+// src/feature/auth/interface/web/react/AuthControllerProvider.tsx
+import { createContext } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var AuthControllerCtx = createContext(null);
+function AuthControllerProvider({ children, controller }) {
+  return /* @__PURE__ */ jsx3(AuthControllerCtx.Provider, { value: controller, children });
+}
+
+// src/feature/auth/interface/web/react/hook/useAuthController.tsx
+function useAuthController() {
+  const authController2 = useContext(AuthControllerCtx);
+  if (!authController2) {
+    throw new Error("useAuthController must be used inside <AuthControllerProvider>");
+  }
+  return authController2;
+}
+
+// src/feature/auth/interface/web/react/AuthProvider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var AuthStateCtx = createContext2(null);
+var AuthDispatchCtx = createContext2(null);
+function AuthProvider({ children }) {
+  const [state, dispatch] = useReducer(authStateReducer, {
+    status: "loading"
+  });
+  const authController2 = useAuthController();
+  useEffect2(() => {
+    const fetchActiveUser = async () => {
+      const res = await authController2.getCurrentUser();
+      if (res.ok) {
+        if (res.value) {
+          dispatch({ type: "COMPLETE", user: res.value });
+        } else {
+          dispatch({ type: "LOGOUT" });
+        }
+      } else {
+        dispatch({ type: "FAILED", error: res.error.message });
+      }
+    };
+    void fetchActiveUser();
+  }, [dispatch, authController2]);
+  return /* @__PURE__ */ jsx4(AuthDispatchCtx.Provider, { value: dispatch, children: /* @__PURE__ */ jsx4(AuthStateCtx.Provider, { value: state, children }) });
+}
+
+// src/feature/auth/interface/web/react/hook/useAuth.tsx
+function useAuth() {
+  const authState = useContext2(AuthStateCtx);
+  if (!authState) {
+    throw new Error("useAuth must be used inside <AuthProvider>");
+  }
+  return authState;
+}
+
+// src/feature/auth/interface/web/react/hook/useAuthActions.tsx
+import { useCallback as useCallback2 } from "react";
+
+// src/feature/auth/interface/web/react/hook/useAuthDispatch.tsx
+import { useContext as useContext3 } from "react";
+function useAuthDispatch() {
+  const dispatch = useContext3(AuthDispatchCtx);
+  if (!dispatch) {
+    throw new Error("useAuthDispatch must be used inside <AuthProvider>");
+  }
+  return dispatch;
+}
+
+// src/feature/auth/interface/web/react/hook/useAuthActions.tsx
+function useAuthActions() {
+  const dispatch = useAuthDispatch();
+  const authController2 = useAuthController();
+  const login = useCallback2((email, password) => {
+    dispatch({ type: "REQUEST" });
+    authController2.login(email, password).then((res) => {
+      dispatchLoginResult(res, dispatch);
+    });
+  }, [dispatch, authController2]);
+  const logout = useCallback2(() => {
+    authController2.logout().then(() => dispatch({ type: "LOGOUT" }));
+  }, [dispatch, authController2]);
+  const register = useCallback2(async (email, password) => {
+    dispatch({ type: "REQUEST" });
+    const res = await authController2.register(email, password);
+    dispatchRegisterResult(res, dispatch);
+    return res;
+  }, [dispatch, authController2]);
+  return { login, logout, register };
+}
+function dispatchLoginResult(res, dispatch) {
+  if (res.ok) {
+    dispatch({ type: "COMPLETE", user: res.value });
+  } else {
+    dispatch({ type: "FAILED", error: res.error.message });
+  }
+}
+function dispatchRegisterResult(res, dispatch) {
+  if (res.ok) {
+    dispatch({ type: "SUCCESS", message: res.value.message });
+  } else {
+    dispatch({ type: "FAILED", error: res.error.message });
+  }
+}
+
+// src/feature/auth/interface/web/react/hook/useAuthedUser.tsx
+function useAuthedUser() {
+  const auth = useAuth();
+  if (auth.status !== "authenticated") {
+    throw new Error("useAuthedUser called outside of an authenticated route");
+  }
+  return auth.user;
+}
+
+// src/feature/auth/interface/web/react/AuthFormInputField.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var inputLabelStyles = {
+  display: "block",
+  fontSize: "small",
+  fontWeight: "bolder",
+  marginBottom: "4px"
+};
+var inputFieldStyles = {
+  display: "block",
+  width: "100%",
+  padding: "0.5rem 0.75rem"
+};
+var AuthFormInputField = ({ id, label, type, value, onChange, placeholder, className }) => {
+  return /* @__PURE__ */ jsxs2("div", { children: [
+    /* @__PURE__ */ jsx5("label", { htmlFor: id, style: inputLabelStyles, children: label }),
+    /* @__PURE__ */ jsx5(
+      "input",
+      {
+        id,
+        name: id,
+        type,
+        required: true,
+        value,
+        onChange,
+        className,
+        placeholder,
+        style: inputFieldStyles
+      }
+    )
+  ] });
+};
+
+// src/feature/auth/infra/mock-auth-http-client.ts
+function httpResponse(data, status = 200) {
+  return { data, status, headers: {} };
+}
+function unauthorized() {
+  return new HttpError("Unauthorized", 401, { error: "Unauthorized" });
+}
+var MockAuthHttpClient = class extends MockHttpClient {
+  fixtures;
+  delayMs;
+  constructor(initial, delayMs = 0) {
+    super();
+    this.fixtures = { currentUser: null, ...initial };
+    this.delayMs = delayMs;
+    this.registerAuthRoutes();
+  }
+  setCurrentUser(user) {
+    this.fixtures.currentUser = user;
+  }
+  setLoginError(error) {
+    this.fixtures.loginError = error;
+  }
+  setRegisterError(error) {
+    this.fixtures.registerError = error;
+  }
+  setMeError(error) {
+    this.fixtures.meError = error;
+  }
+  setLogoutError(error) {
+    this.fixtures.logoutError = error;
+  }
+  registerAuthRoutes() {
+    this.register("GET", "/auth/me", async () => {
+      await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+      if (this.fixtures.meError) {
+        throw this.fixtures.meError;
+      }
+      if (this.fixtures.currentUser) {
+        return httpResponse({ user: this.fixtures.currentUser });
+      }
+      throw unauthorized();
+    });
+    this.register("POST", "/auth/login", async (payload) => {
+      await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+      if (this.fixtures.loginError) {
+        throw this.fixtures.loginError;
+      }
+      const body = payload.data;
+      this.fixtures.currentUser ||= {
+        id: "mock-user",
+        email: body.email
+      };
+      return httpResponse({ message: "Logged in" });
+    });
+    this.register("POST", "/auth/register", async () => {
+      await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+      if (this.fixtures.registerError) {
+        throw this.fixtures.registerError;
+      }
+      return httpResponse({ message: "Registered" });
+    });
+    this.register("POST", "/auth/logout", async () => {
+      await new Promise((resolve) => setTimeout(resolve, this.delayMs));
+      if (this.fixtures.logoutError) {
+        throw this.fixtures.logoutError;
+      }
+      this.fixtures.currentUser = null;
+      return httpResponse(null);
+    });
+  }
+};
 export {
+  AuthController,
+  AuthControllerCtx,
+  AuthControllerProvider,
+  AuthDispatchCtx,
+  AuthFormInputField,
+  AuthProvider,
+  AuthStateCtx,
   DEFAULT_NOTIFICATION_CHANNEL,
+  HttpError,
+  MockAuthHttpClient,
+  MockHttpClient,
   NotificationHost,
   NotifierController,
+  authController,
+  controllerFactory,
+  createAuthController,
+  httpClient as fetchHttpClient,
   notifierController,
   resolveToastTheme,
   ui,
+  useAuth,
+  useAuthActions,
+  useAuthController,
+  useAuthDispatch,
+  useAuthedUser,
   useResponsiveMutation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexdspace/react",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,7 @@
     "react-router-dom": "^7.10.1",
     "react-toastify": "^11.0.5",
     "uuid": "^13.0.0",
-    "@hexdspace/util": "0.0.24"
+    "@hexdspace/util": "0.0.25"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.90.11",