alepha 0.15.1 → 0.15.3

package/dist/react/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/react/auth/providers/ReactAuthProvider.ts","../../../src/react/auth/services/ReactAuth.ts","../../../src/react/auth/hooks/useAuth.ts","../../../src/react/auth/index.ts"],"sourcesContent":["import { $hook, $inject, Alepha } from \"alepha\";\n\nexport class ReactAuthProvider {\n  protected readonly alepha = $inject(Alepha);\n\n  public readonly onRender = $hook({\n    on: \"react:server:render:begin\",\n    handler: async ({ request, state }) => {\n      if (request?.user) {\n        const { token, realm, ...user } = request.user; // do not send token and realm to the client\n        this.alepha.store.set(\"alepha.server.request.user\", user); // for hydration, browser, etc...\n        state.user = user;\n      }\n    },\n  });\n}\n","import { $hook, $inject, Alepha } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport { ReactBrowserProvider, Redirection } from \"alepha/react/router\";\nimport type { UserAccountToken } from \"alepha/security\";\nimport { HttpClient } from \"alepha/server\";\nimport {\n  alephaServerAuthRoutes,\n  type Tokens,\n  tokenResponseSchema,\n  userinfoResponseSchema,\n} from \"alepha/server/auth\";\nimport { LinkProvider } from \"alepha/server/links\";\n\n/**\n * Browser, SSR friendly, service to handle authentication.\n */\nexport class ReactAuth {\n  protected readonly log = $logger();\n  protected readonly alepha = $inject(Alepha);\n  protected readonly httpClient = $inject(HttpClient);\n  protected readonly linkProvider = $inject(LinkProvider);\n\n  protected readonly onBeginTransition = $hook({\n    on: \"react:transition:begin\",\n    handler: async (event) => {\n      if (this.alepha.isBrowser()) {\n        Object.defineProperty(event.state, \"user\", {\n          get: () => this.user,\n        });\n      }\n    },\n  });\n\n  protected readonly onFetchRequest = $hook({\n    on: \"client:onRequest\",\n    handler: async ({ request }) => {\n      if (this.alepha.isBrowser() && this.user) {\n        // ensure cookies are sent with requests and refresh-able\n        request.credentials ??= \"include\";\n      }\n    },\n  });\n\n  /**\n   * Get the current authenticated user.\n   *\n   * Alias for `alepha.state.get(\"user\")`\n   */\n  public get user(): UserAccountToken | undefined {\n    return this.alepha.store.get(\"alepha.server.request.user\");\n  }\n\n  public async ping() {\n    const { data } = await this.httpClient.fetch(\n      alephaServerAuthRoutes.userinfo,\n      {\n        schema: { response: userinfoResponseSchema },\n      },\n    );\n\n    this.alepha.store.set(\"alepha.server.request.apiLinks\", data.api);\n    this.alepha.store.set(\"alepha.server.request.user\", data.user);\n\n    return data.user;\n  }\n\n  public can(action: string): boolean {\n    if (!this.user) {\n      return false;\n    }\n\n    return this.linkProvider.can(action);\n  }\n\n  public async login(\n    provider: string,\n    options: {\n      hostname?: string;\n      username?: string;\n      password?: string;\n      redirect?: string;\n      realm?: string;\n      [extra: string]: any;\n    },\n  ): Promise<Tokens> {\n    const realmParam = options.realm\n      ? `&realm=${encodeURIComponent(options.realm)}`\n      : \"\";\n\n    if (options.username || options.password) {\n      const { data } = await this.httpClient.fetch(\n        `${options.hostname || \"\"}${alephaServerAuthRoutes.token}?provider=${provider}${realmParam}`,\n        {\n          method: \"POST\",\n          body: JSON.stringify({\n            username: options.username,\n            password: options.password,\n          }),\n          schema: { response: tokenResponseSchema },\n        },\n      );\n\n      this.alepha.store.set(\"alepha.server.request.apiLinks\", data.api);\n      this.alepha.store.set(\"alepha.server.request.user\", data.user);\n\n      return data;\n    }\n\n    if (this.alepha.isBrowser()) {\n      const browser = this.alepha.inject(ReactBrowserProvider);\n      const redirect =\n        options.redirect ||\n        (browser.transitioning\n          ? window.location.origin + browser.transitioning.to\n          : window.location.href);\n\n      const href = `${window.location.origin}${alephaServerAuthRoutes.login}?provider=${provider}${realmParam}&redirect_uri=${encodeURIComponent(redirect)}`;\n\n      if (browser.transitioning) {\n        throw new Redirection(href);\n      } else {\n        window.location.href = href;\n        return {} as Tokens;\n      }\n    }\n\n    throw new Redirection(\n      `${alephaServerAuthRoutes.login}?provider=${provider}${realmParam}&redirect_uri=${options.redirect || \"/\"}`,\n    );\n  }\n\n  public logout() {\n    window.location.href = `${alephaServerAuthRoutes.logout}?post_logout_redirect_uri=${encodeURIComponent(window.location.origin)}`;\n  }\n}\n","import { useAlepha, useStore } from \"alepha/react\";\nimport { type HttpVirtualClient, LinkProvider } from \"alepha/server/links\";\nimport { ReactAuth } from \"../services/ReactAuth.ts\";\n\nexport const useAuth = <T extends object = any>() => {\n  const alepha = useAlepha();\n  const [user] = useStore(\"alepha.server.request.user\");\n\n  return {\n    user,\n    logout: () => {\n      alepha.inject(ReactAuth).logout();\n    },\n    login: async (\n      provider: keyof T,\n      options: {\n        username?: string;\n        password?: string;\n        redirect?: string;\n        realm?: string;\n        [extra: string]: any;\n      } = {},\n    ) => {\n      await alepha.inject(ReactAuth).login(provider as string, options);\n    },\n    can: <Api extends object = any>(\n      name: keyof HttpVirtualClient<Api>,\n    ): boolean => {\n      return alepha.inject(LinkProvider).can(name as string);\n    },\n  };\n};\n","import { $module } from \"alepha\";\nimport { AlephaReact } from \"alepha/react\";\nimport type { UserAccount } from \"alepha/security\";\nimport { $auth, AlephaServerAuth } from \"alepha/server/auth\";\nimport { AlephaServerLinks } from \"alepha/server/links\";\nimport { ReactAuthProvider } from \"./providers/ReactAuthProvider.ts\";\nimport { ReactAuth } from \"./services/ReactAuth.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./index.shared.ts\";\nexport * from \"./providers/ReactAuthProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha/react/router\" {\n  interface ReactRouterState {\n    user?: UserAccount;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * | type | quality | stability |\n * |------|---------|-----------|\n * | frontend | rare | stable |\n *\n * Auth-related React components and hooks.\n *\n * **Features:**\n * - Login/logout components\n * - Protected route wrappers\n * - Auth state hooks\n *\n * @module alepha.react.auth\n */\nexport const AlephaReactAuth = $module({\n  name: \"alepha.react.auth\",\n  primitives: [$auth],\n  services: [\n    AlephaReact,\n    AlephaServerLinks,\n    AlephaServerAuth,\n    ReactAuthProvider,\n    ReactAuth,\n  ],\n});\n"],"mappings":"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"}

package/dist/react/core/index.d.ts

@@ -0,0 +1,469 @@
+import * as alepha0 from "alepha";
+import { Alepha, Async, Atom, Hook, Hooks, Service, State, Static, TAtomObject } from "alepha";
+import * as react0 from "react";
+import React, { DependencyList, ErrorInfo, PropsWithChildren, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { DurationLike } from "alepha/datetime";
+import { ClientScope, HttpVirtualClient } from "alepha/server/links";
+
+//#region ../../src/react/core/components/ClientOnly.d.ts
+interface ClientOnlyProps {
+  fallback?: ReactNode;
+  disabled?: boolean;
+}
+/**
+ * A small utility component that renders its children only on the client side.
+ *
+ * Optionally, you can provide a fallback React node that will be rendered.
+ *
+ * You should use this component when
+ * - you have code that relies on browser-specific APIs
+ * - you want to avoid server-side rendering for a specific part of your application
+ * - you want to prevent pre-rendering of a component
+ *
+ * @example
+ * ```tsx
+ * import { ClientOnly } from "alepha/react";
+ *
+ * const MyComponent = () => {
+ *   // Avoids SSR issues with Date API
+ *   return (
+ *     <ClientOnly>
+ *       {new Date().toLocaleTimeString()}
+ *     </ClientOnly>
+ *   );
+ * }
+ * ```
+ */
+declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
+//#endregion
+//#region ../../src/react/core/components/ErrorBoundary.d.ts
+/**
+ * Props for the ErrorBoundary component.
+ */
+interface ErrorBoundaryProps {
+  /**
+   * Fallback React node to render when an error is caught.
+   * If not provided, a default error message will be shown.
+   */
+  fallback: (error: Error) => ReactNode;
+  /**
+   * Optional callback that receives the error and error info.
+   * Use this to log errors to a monitoring service.
+   */
+  onError?: (error: Error, info: ErrorInfo) => void;
+}
+/**
+ * State of the ErrorBoundary component.
+ */
+interface ErrorBoundaryState {
+  error?: Error;
+}
+/**
+ * A reusable error boundary for catching rendering errors in any part of the React component tree.
+ *
+ * It's already included in the Alepha React framework when using page or layout components.
+ */
+declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
+  constructor(props: ErrorBoundaryProps);
+  /**
+   * Update state so the next render shows the fallback UI.
+   */
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+  /**
+   * Lifecycle method called when an error is caught.
+   * You can log the error or perform side effects here.
+   */
+  componentDidCatch(error: Error, info: ErrorInfo): void;
+  render(): ReactNode;
+}
+//#endregion
+//#region ../../src/react/core/contexts/AlephaContext.d.ts
+/**
+ * React context to provide the Alepha instance throughout the component tree.
+ */
+declare const AlephaContext: react0.Context<Alepha | undefined>;
+//#endregion
+//#region ../../src/react/core/contexts/AlephaProvider.d.ts
+interface AlephaProviderProps {
+  children: ReactNode;
+  onError: (error: Error) => ReactNode;
+  onLoading: () => ReactNode;
+}
+/**
+ * AlephaProvider component to initialize and provide Alepha instance to the app.
+ *
+ * This isn't recommended for apps using `alepha/react/router`, as Router will handle this for you.
+ */
+declare const AlephaProvider: (props: AlephaProviderProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react0.ReactPortal | react0.ReactElement<unknown, string | react0.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime0.JSX.Element | null | undefined;
+//#endregion
+//#region ../../src/react/core/hooks/useAction.d.ts
+/**
+ * Hook for handling async actions with automatic error handling and event emission.
+ *
+ * By default, prevents concurrent executions - if an action is running and you call it again,
+ * the second call will be ignored. Use `debounce` option to delay execution instead.
+ *
+ * Emits lifecycle events:
+ * - `react:action:begin` - When action starts
+ * - `react:action:success` - When action completes successfully
+ * - `react:action:error` - When action throws an error
+ * - `react:action:end` - Always emitted at the end
+ *
+ * @example Basic usage
+ * ```tsx
+ * const action = useAction({
+ *   handler: async (data) => {
+ *     await api.save(data);
+ *   }
+ * }, []);
+ *
+ * <button onClick={() => action.run(data)} disabled={action.loading}>
+ *   Save
+ * </button>
+ * ```
+ *
+ * @example With debounce (search input)
+ * ```tsx
+ * const search = useAction({
+ *   handler: async (query: string) => {
+ *     await api.search(query);
+ *   },
+ *   debounce: 300 // Wait 300ms after last call
+ * }, []);
+ *
+ * <input onChange={(e) => search.run(e.target.value)} />
+ * ```
+ *
+ * @example Run on component mount
+ * ```tsx
+ * const fetchData = useAction({
+ *   handler: async () => {
+ *     const data = await api.getData();
+ *     return data;
+ *   },
+ *   runOnInit: true // Runs once when component mounts
+ * }, []);
+ * ```
+ *
+ * @example Run periodically (polling)
+ * ```tsx
+ * const pollStatus = useAction({
+ *   handler: async () => {
+ *     const status = await api.getStatus();
+ *     return status;
+ *   },
+ *   runEvery: 5000 // Run every 5 seconds
+ * }, []);
+ *
+ * // Or with duration tuple
+ * const pollStatus = useAction({
+ *   handler: async () => {
+ *     const status = await api.getStatus();
+ *     return status;
+ *   },
+ *   runEvery: [30, 'seconds'] // Run every 30 seconds
+ * }, []);
+ * ```
+ *
+ * @example With AbortController
+ * ```tsx
+ * const fetch = useAction({
+ *   handler: async (url, { signal }) => {
+ *     const response = await fetch(url, { signal });
+ *     return response.json();
+ *   }
+ * }, []);
+ * // Automatically cancelled on unmount or when new request starts
+ * ```
+ *
+ * @example With error handling
+ * ```tsx
+ * const deleteAction = useAction({
+ *   handler: async (id: string) => {
+ *     await api.delete(id);
+ *   },
+ *   onError: (error) => {
+ *     if (error.code === 'NOT_FOUND') {
+ *       // Custom error handling
+ *     }
+ *   }
+ * }, []);
+ *
+ * {deleteAction.error && <div>Error: {deleteAction.error.message}</div>}
+ * ```
+ *
+ * @example Global error handling
+ * ```tsx
+ * // In your root app setup
+ * alepha.events.on("react:action:error", ({ error }) => {
+ *   toast.danger(error.message);
+ *   Sentry.captureException(error);
+ * });
+ * ```
+ */
+declare function useAction<Args extends any[], Result = void>(options: UseActionOptions<Args, Result>, deps: DependencyList): UseActionReturn<Args, Result>;
+/**
+ * Context object passed as the last argument to action handlers.
+ * Contains an AbortSignal that can be used to cancel the request.
+ */
+interface ActionContext {
+  /**
+   * AbortSignal that can be passed to fetch or other async operations.
+   * The signal will be aborted when:
+   * - The component unmounts
+   * - A new action is triggered (cancels previous)
+   * - The cancel() method is called
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({
+   *   handler: async (url, { signal }) => {
+   *     const response = await fetch(url, { signal });
+   *     return response.json();
+   *   }
+   * }, []);
+   * ```
+   */
+  signal: AbortSignal;
+}
+interface UseActionOptions<Args extends any[] = any[], Result = any> {
+  /**
+   * The async action handler function.
+   * Receives the action arguments plus an ActionContext as the last parameter.
+   */
+  handler: (...args: [...Args, ActionContext]) => Async<Result>;
+  /**
+   * Custom error handler. If provided, prevents default error re-throw.
+   */
+  onError?: (error: Error) => void | Promise<void>;
+  /**
+   * Custom success handler.
+   */
+  onSuccess?: (result: Result) => void | Promise<void>;
+  /**
+   * Optional identifier for this action (useful for debugging/analytics)
+   */
+  id?: string;
+  name?: string;
+  /**
+   * Debounce delay in milliseconds. If specified, the action will only execute
+   * after the specified delay has passed since the last call. Useful for search inputs
+   * or other high-frequency events.
+   *
+   * @example
+   * ```tsx
+   * // Execute search 300ms after user stops typing
+   * const search = useAction({ handler: search, debounce: 300 }, [])
+   * ```
+   */
+  debounce?: number;
+  /**
+   * If true, the action will be executed once when the component mounts.
+   *
+   * @example
+   * ```tsx
+   * const fetchData = useAction({
+   *   handler: async () => await api.getData(),
+   *   runOnInit: true
+   * }, []);
+   * ```
+   */
+  runOnInit?: boolean;
+  /**
+   * If specified, the action will be executed periodically at the given interval.
+   * The interval is specified as a DurationLike value (number in ms, Duration object, or [number, unit] tuple).
+   *
+   * @example
+   * ```tsx
+   * // Run every 5 seconds
+   * const poll = useAction({
+   *   handler: async () => await api.poll(),
+   *   runEvery: 5000
+   * }, []);
+   * ```
+   *
+   * @example
+   * ```tsx
+   * // Run every 1 minute
+   * const poll = useAction({
+   *   handler: async () => await api.poll(),
+   *   runEvery: [1, 'minute']
+   * }, []);
+   * ```
+   */
+  runEvery?: DurationLike;
+}
+interface UseActionReturn<Args extends any[], Result> {
+  /**
+   * Execute the action with the provided arguments.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ handler: async (data) => { ... } }, []);
+   * action.run(data);
+   * ```
+   */
+  run: (...args: Args) => Promise<Result | undefined>;
+  /**
+   * Loading state - true when action is executing.
+   */
+  loading: boolean;
+  /**
+   * Error state - contains error if action failed, undefined otherwise.
+   */
+  error?: Error;
+  /**
+   * Cancel any pending debounced action or abort the current in-flight request.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ ... }, []);
+   *
+   * <button onClick={action.cancel} disabled={!action.loading}>
+   *   Cancel
+   * </button>
+   * ```
+   */
+  cancel: () => void;
+  /**
+   * The result data from the last successful action execution.
+   */
+  result?: Result;
+}
+//#endregion
+//#region ../../src/react/core/hooks/useAlepha.d.ts
+/**
+ * Main Alepha hook.
+ *
+ * It provides access to the Alepha instance within a React component.
+ *
+ * With Alepha, you can access the core functionalities of the framework:
+ *
+ * - alepha.state() for state management
+ * - alepha.inject() for dependency injection
+ * - alepha.events.emit() for event handling
+ * etc...
+ */
+declare const useAlepha: () => Alepha;
+//#endregion
+//#region ../../src/react/core/hooks/useClient.d.ts
+/**
+ * Hook to get a virtual client for the specified scope.
+ *
+ * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.
+ */
+declare const useClient: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
+//#endregion
+//#region ../../src/react/core/hooks/useEvents.d.ts
+/**
+ * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.
+ *
+ * useEvents is fully typed to ensure correct event callback signatures.
+ *
+ * @example
+ * ```tsx
+ * useEvents(
+ *   {
+ *     "react:transition:begin": (ev) => {
+ *       console.log("Transition began to:", ev.to);
+ *     },
+ *     "react:transition:error": {
+ *       priority: "first",
+ *       callback: (ev) => {
+ *         console.error("Transition error:", ev.error);
+ *       },
+ *     },
+ *   },
+ *   [],
+ * );
+ * ```
+ */
+declare const useEvents: (opts: UseEvents, deps: DependencyList) => void;
+type UseEvents = { [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<void>) };
+//#endregion
+//#region ../../src/react/core/hooks/useInject.d.ts
+/**
+ * Hook to inject a service instance.
+ * It's a wrapper of `useAlepha().inject(service)` with a memoization.
+ */
+declare const useInject: <T extends object>(service: Service<T>) => T;
+//#endregion
+//#region ../../src/react/core/hooks/useStore.d.ts
+/**
+ * Hook to access and mutate the Alepha state.
+ */
+declare function useStore<T extends TAtomObject>(target: Atom<T>, defaultValue?: Static<T>): UseStoreReturn<Static<T>>;
+declare function useStore<Key extends keyof State>(target: Key, defaultValue?: State[Key]): UseStoreReturn<State[Key]>;
+type UseStoreReturn<T> = [T, (value: T) => void];
+//#endregion
+//#region ../../src/react/core/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    /**
+     * Fires when a user action is starting.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:begin": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has succeeded.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:success": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has failed.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:error": {
+      type: string;
+      id?: string;
+      error: Error;
+    };
+    /**
+     * Fires when a user action has completed, regardless of success or failure.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:end": {
+      type: string;
+      id?: string;
+    };
+  }
+}
+/**
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | frontend | epic | stable |
+ *
+ * Full-stack React framework with server-side rendering.
+ *
+ * **Features:**
+ * - React page routes with type-safe params
+ * - Async action handler with loading/error/cancel states
+ * - Type-safe HTTP client access
+ * - Dependency injection in components
+ * - Global state management
+ * - Router navigation methods
+ * - Current route state access
+ * - Check if path is active
+ * - URL query parameters
+ * - Access route schema
+ * - Subscribe to Alepha events
+ * - Type-safe form handling with validation
+ * - Error handling wrapper component
+ * - Client-side only rendering component
+ * - Server-side rendering with hydration
+ * - Automatic code splitting
+ * - Event system for action tracking
+ *
+ * @module alepha.react
+ */
+declare const AlephaReact: alepha0.Service<alepha0.Module>;
+//#endregion
+export { ActionContext, AlephaContext, AlephaProvider, AlephaProviderProps, AlephaReact, ClientOnly, ClientOnlyProps, ErrorBoundary, ErrorBoundaryProps, UseActionOptions, UseActionReturn, UseStoreReturn, useAction, useAlepha, useClient, useEvents, useInject, useStore };
+//# sourceMappingURL=index.d.ts.map

package/dist/react/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/react/core/components/ClientOnly.tsx","../../../src/react/core/components/ErrorBoundary.tsx","../../../src/react/core/contexts/AlephaContext.ts","../../../src/react/core/contexts/AlephaProvider.tsx","../../../src/react/core/hooks/useAction.ts","../../../src/react/core/hooks/useAlepha.ts","../../../src/react/core/hooks/useClient.ts","../../../src/react/core/hooks/useEvents.ts","../../../src/react/core/hooks/useInject.ts","../../../src/react/core/hooks/useStore.ts","../../../src/react/core/index.ts"],"mappings":"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"}