npm - @alepha/react - Versions diffs - 0.12.1 → 0.13.1 - Mend

@alepha/react 0.12.1 → 0.13.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/dist/auth/index.browser.js +4 -1642
package/dist/auth/index.browser.js.map +1 -1
package/dist/auth/index.d.ts +1 -1
package/dist/auth/index.js +4 -1642
package/dist/auth/index.js.map +1 -1
package/dist/core/index.d.ts +83 -83
package/dist/form/index.d.ts +1 -1
package/dist/form/index.js +3 -1642
package/dist/form/index.js.map +1 -1
package/dist/head/index.browser.js +3 -1654
package/dist/head/index.browser.js.map +1 -1
package/dist/head/index.d.ts +149 -885
package/dist/head/index.js +4 -1654
package/dist/head/index.js.map +1 -1
package/dist/i18n/index.js +3 -1653
package/dist/i18n/index.js.map +1 -1
package/dist/websocket/index.d.ts +159 -3
package/dist/websocket/index.js +2 -1654
package/dist/websocket/index.js.map +1 -1
package/package.json +9 -15
package/dist/auth/chunk-DhGyd7sr.js +0 -28
package/dist/auth/index.cjs +0 -1800
package/dist/auth/index.cjs.map +0 -1
package/dist/auth/index.d.cts +0 -1274
package/dist/core/chunk-DhGyd7sr.js +0 -28
package/dist/core/index.cjs +0 -2087
package/dist/core/index.cjs.map +0 -1
package/dist/core/index.d.cts +0 -2763
package/dist/form/chunk-DhGyd7sr.js +0 -28
package/dist/form/index.cjs +0 -2074
package/dist/form/index.cjs.map +0 -1
package/dist/form/index.d.cts +0 -419
package/dist/head/chunk-DhGyd7sr.js +0 -28
package/dist/head/index.cjs +0 -1912
package/dist/head/index.cjs.map +0 -1
package/dist/head/index.d.cts +0 -1801
package/dist/i18n/chunk-DhGyd7sr.js +0 -28
package/dist/i18n/index.cjs +0 -1899
package/dist/i18n/index.cjs.map +0 -1
package/dist/i18n/index.d.cts +0 -437
package/dist/websocket/index.cjs +0 -1787
package/dist/websocket/index.cjs.map +0 -1
package/dist/websocket/index.d.cts +0 -118
package/src/i18n/README.md +0 -76

package/dist/head/index.d.ts CHANGED Viewed

@@ -1,23 +1,107 @@
-import * as alepha93 from "alepha";
-import { Alepha, AlephaError, Async, Atom, Descriptor, FileLike, InstantiableClass, KIND, LogLevel, LoggerInterface, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import React, { FC, ReactNode } from "react";
-import "react/jsx-runtime";
+import { PageConfigSchema, PageRoute, ReactRouterState, TPropsDefault, TPropsParentDefault } from "@alepha/react";
+import * as alepha53 from "alepha";
+import { Alepha, AlephaError, Async, Descriptor, FileLike, InstantiableClass, KIND, LogLevel, LoggerInterface, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
 import { IncomingMessage, Server, ServerResponse } from "node:http";
 import dayjsDuration from "dayjs/plugin/duration.js";
 import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
+//#region src/head/interfaces/Head.d.ts
+interface Head extends SimpleHead {
+  description?: string;
+  keywords?: string[];
+  author?: string;
+  robots?: string;
+  themeColor?: string;
+  viewport?: string | {
+    width?: string;
+    height?: string;
+    initialScale?: string;
+    maximumScale?: string;
+    userScalable?: "no" | "yes" | "0" | "1";
+    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
+  };
+  og?: {
+    title?: string;
+    description?: string;
+    image?: string;
+    url?: string;
+    type?: string;
+  };
+  twitter?: {
+    card?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    site?: string;
+  };
+}
+interface SimpleHead {
+  title?: string;
+  titleSeparator?: string;
+  htmlAttributes?: Record<string, string>;
+  bodyAttributes?: Record<string, string>;
+  meta?: Array<{
+    name: string;
+    content: string;
+  }>;
+}
+//#endregion
+//#region src/head/providers/HeadProvider.d.ts
+declare class HeadProvider {
+  global?: Head | (() => Head);
+  protected getGlobalHead(): Head | undefined;
+  fillHead(state: ReactRouterState): void;
+  protected fillHeadByPage(page: PageRoute, state: ReactRouterState, props: Record<string, any>): void;
+}
+//#endregion
+//#region src/head/descriptors/$head.d.ts
+/**
+ * Set global `<head>` options for the application.
+ */
+declare const $head: {
+  (options: HeadDescriptorOptions): HeadDescriptor;
+  [KIND]: typeof HeadDescriptor;
+};
+type HeadDescriptorOptions = Head | (() => Head);
+declare class HeadDescriptor extends Descriptor<HeadDescriptorOptions> {
+  protected readonly provider: HeadProvider;
+  protected onInit(): void;
+}
+//#endregion
+//#region src/head/hooks/useHead.d.ts
+/**
+ * ```tsx
+ * const App = () => {
+ *   const [head, setHead] = useHead({
+ *     // will set the document title on the first render
+ *     title: "My App",
+ *   });
+ *
+ *   return (
+ *     // This will update the document title when the button is clicked
+ *     <button onClick={() => setHead({ title: "Change Title" })}>
+ *       Change Title {head.title}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare const useHead: (options?: UseHeadOptions) => UseHeadReturn;
+type UseHeadOptions = Head | ((previous?: Head) => Head);
+type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
+//#endregion
 //#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
-declare const logEntrySchema: alepha93.TObject<{
-  level: alepha93.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha93.TString;
-  service: alepha93.TString;
-  module: alepha93.TString;
-  context: alepha93.TOptional<alepha93.TString>;
-  app: alepha93.TOptional<alepha93.TString>;
-  data: alepha93.TOptional<alepha93.TAny>;
-  timestamp: alepha93.TNumber;
+declare const logEntrySchema: alepha53.TObject<{
+  level: alepha53.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha53.TString;
+  service: alepha53.TString;
+  module: alepha53.TString;
+  context: alepha53.TOptional<alepha53.TString>;
+  app: alepha53.TOptional<alepha53.TString>;
+  data: alepha53.TOptional<alepha53.TAny>;
+  timestamp: alepha53.TNumber;
 }>;
 type LogEntry = Static<typeof logEntrySchema>;
 //#endregion
@@ -32,8 +116,8 @@ declare class DateTimeProvider {
   protected readonly timeouts: Timeout[];
   protected readonly intervals: Interval[];
   constructor();
-  protected readonly onStart: alepha93.HookDescriptor<"start">;
-  protected readonly onStop: alepha93.HookDescriptor<"stop">;
+  protected readonly onStart: alepha53.HookDescriptor<"start">;
+  protected readonly onStop: alepha53.HookDescriptor<"stop">;
   setLocale(locale: string): void;
   isDateTime(value: unknown): value is DateTime;
   /**
@@ -100,7 +184,7 @@ declare class DateTimeProvider {
   /**
    * Run a function with a deadline.
    */
-  deadline<T$1>(fn: (signal: AbortSignal) => Promise<T$1>, duration: DurationLike): Promise<T$1>;
+  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
   /**
    * Add time to the current date.
    */
@@ -165,7 +249,7 @@ declare class Logger implements LoggerInterface {
 }
 //#endregion
 //#region ../alepha/src/logger/index.d.ts
-declare const envSchema$6: alepha93.TObject<{
+declare const envSchema$2: alepha53.TObject<{
   /**
    * Default log level for the application.
    *
@@ -182,17 +266,17 @@ declare const envSchema$6: alepha93.TObject<{
    * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
    * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
    */
-  LOG_LEVEL: alepha93.TOptional<alepha93.TString>;
+  LOG_LEVEL: alepha53.TOptional<alepha53.TString>;
   /**
    * Built-in log formats.
    * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
    * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
    * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
    */
-  LOG_FORMAT: alepha93.TOptional<alepha93.TUnsafe<"json" | "pretty" | "raw">>;
+  LOG_FORMAT: alepha53.TOptional<alepha53.TUnsafe<"json" | "pretty" | "raw">>;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$6>> {}
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
   interface State {
     /**
      * Current log level for the application or specific modules.
@@ -212,19 +296,19 @@ declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "
 type RouteMethod = (typeof routeMethods)[number];
 //#endregion
 //#region ../alepha/src/router/providers/RouterProvider.d.ts
-declare abstract class RouterProvider<T$1 extends Route = Route> {
+declare abstract class RouterProvider<T extends Route = Route> {
   protected routePathRegex: RegExp;
-  protected tree: Tree<T$1>;
-  protected cache: Map<string, RouteMatch<T$1>>;
-  match(path: string): RouteMatch<T$1>;
+  protected tree: Tree<T>;
+  protected cache: Map<string, RouteMatch<T>>;
+  match(path: string): RouteMatch<T>;
   protected test(path: string): void;
-  protected push(route: T$1): void;
-  protected createRouteMatch(path: string): RouteMatch<T$1>;
-  protected mapParams(match: RouteMatch<T$1>): RouteMatch<T$1>;
+  protected push(route: T): void;
+  protected createRouteMatch(path: string): RouteMatch<T>;
+  protected mapParams(match: RouteMatch<T>): RouteMatch<T>;
   protected createParts(path: string): string[];
 }
-interface RouteMatch<T$1 extends Route> {
-  route?: T$1;
+interface RouteMatch<T extends Route> {
+  route?: T;
   params?: Record<string, string>;
 }
 interface Route {
@@ -238,20 +322,20 @@ interface Route {
    */
   mapParams?: Record<string, string>;
 }
-interface Tree<T$1 extends Route> {
-  route?: T$1;
+interface Tree<T extends Route> {
+  route?: T;
   children: {
-    [key: string]: Tree<T$1>;
+    [key: string]: Tree<T>;
   };
   param?: {
-    route?: T$1;
+    route?: T;
     name: string;
     children: {
-      [key: string]: Tree<T$1>;
+      [key: string]: Tree<T>;
     };
   };
   wildcard?: {
-    route: T$1;
+    route: T;
   };
 }
 //#endregion
@@ -440,8 +524,8 @@ declare class ServerTimingProvider {
     prefix: string;
     disabled: boolean;
   };
-  readonly onRequest: alepha93.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha93.HookDescriptor<"server:onResponse">;
+  readonly onRequest: alepha53.HookDescriptor<"server:onRequest">;
+  readonly onResponse: alepha53.HookDescriptor<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
@@ -505,11 +589,11 @@ declare class ServerProvider {
   /**
    * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
    */
-  protected readonly onNodeRequest: alepha93.HookDescriptor<"node:request">;
+  protected readonly onNodeRequest: alepha53.HookDescriptor<"node:request">;
   /**
    * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
    */
-  protected readonly onWebRequest: alepha93.HookDescriptor<"web:request">;
+  protected readonly onWebRequest: alepha53.HookDescriptor<"web:request">;
   /**
    * Handle Node.js HTTP request event.
    *
@@ -643,7 +727,7 @@ declare class HttpClient {
   readonly cache: CacheDescriptorFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T$1 extends TSchema>(url: string, request?: RequestInitWithOptions<T$1>): Promise<FetchResponse<Static<T$1>>>;
+  fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
   protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
   protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
   protected responseData(response: Response, options: FetchOptions): Promise<any>;
@@ -660,7 +744,7 @@ declare class HttpClient {
     };
   }, args?: ServerRequestConfigEntry): string;
 }
-interface FetchOptions<T$1 extends TSchema = TSchema> {
+interface FetchOptions<T extends TSchema = TSchema> {
   /**
    * Key to identify the request in the pending requests.
    */
@@ -669,16 +753,16 @@ interface FetchOptions<T$1 extends TSchema = TSchema> {
    * The schema to validate the response against.
    */
   schema?: {
-    response?: T$1;
+    response?: T;
   };
   /**
    * Built-in cache options.
    */
   localCache?: boolean | number | DurationLike;
 }
-type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
-interface FetchResponse<T$1 = any> {
-  data: T$1;
+type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
+interface FetchResponse<T = any> {
+  data: T;
   status: number;
   statusText: string;
   headers: Headers;
@@ -816,7 +900,7 @@ declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Desc
    */
   fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
 }
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
 type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
   body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
   params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
@@ -844,15 +928,15 @@ type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSche
 interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
 //#endregion
 //#region ../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha93.TObject<{
-  error: alepha93.TString;
-  status: alepha93.TInteger;
-  message: alepha93.TString;
-  details: alepha93.TOptional<alepha93.TString>;
-  requestId: alepha93.TOptional<alepha93.TString>;
-  cause: alepha93.TOptional<alepha93.TObject<{
-    name: alepha93.TString;
-    message: alepha93.TString;
+declare const errorSchema: alepha53.TObject<{
+  error: alepha53.TString;
+  status: alepha53.TInteger;
+  message: alepha53.TString;
+  details: alepha53.TOptional<alepha53.TString>;
+  requestId: alepha53.TOptional<alepha53.TString>;
+  cause: alepha53.TOptional<alepha53.TObject<{
+    name: alepha53.TString;
+    message: alepha53.TString;
   }>>;
 }>;
 type ErrorSchema = Static<typeof errorSchema>;
@@ -877,21 +961,21 @@ interface HttpErrorLike extends Error {
 }
 //#endregion
 //#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$5: alepha93.TObject<{
-  SERVER_PORT: alepha93.TInteger;
-  SERVER_HOST: alepha93.TString;
+declare const envSchema$1: alepha53.TObject<{
+  SERVER_PORT: alepha53.TInteger;
+  SERVER_HOST: alepha53.TString;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$5>> {}
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 //#endregion
 //#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$4: alepha93.TObject<{
-  SERVER_PORT: alepha93.TInteger;
-  SERVER_HOST: alepha93.TString;
+declare const envSchema: alepha53.TObject<{
+  SERVER_PORT: alepha53.TInteger;
+  SERVER_HOST: alepha53.TString;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$4>> {}
+  interface Env extends Partial<Static<typeof envSchema>> {}
 }
 //#endregion
 //#region ../alepha/src/server/index.d.ts
@@ -950,831 +1034,11 @@ declare module "alepha" {
   }
 }
 //#endregion
-//#region ../alepha/src/server-cache/providers/ServerCacheProvider.d.ts
-declare module "alepha/server" {
-  interface ServerRoute {
-    /**
-     * Enable caching for this route.
-     * - If true: enables both store and etag
-     * - If object: fine-grained control over store, etag, and cache-control headers
-     *
-     * @default false
-     */
-    cache?: ServerRouteCache;
-  }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
-    invalidate: () => Promise<void>;
-  }
-}
-type ServerRouteCache =
-/**
- * If true, enables caching with:
- * - store: true
- * - etag: true
- */
-boolean
-/**
- * Object configuration for fine-grained cache control.
- *
- * If empty, no caching will be applied.
- */ | {
-  /**
-   * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
-   * If a DurationLike is provided, it will be used as the TTL for the cache.
-   * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
-   *
-   * @default false
-   */
-  store?: true | DurationLike | CacheDescriptorOptions;
-  /**
-   * If true, enables ETag support for the cached responses.
-   */
-  etag?: true;
-  /**
-   * - If true, sets Cache-Control to "public, max-age=300" (5 minutes).
-   * - If string, sets Cache-Control to the provided value directly.
-   * - If object, configures Cache-Control directives.
-   */
-  control?: true
-  /**
-   * If string, sets Cache-Control to the provided value directly.
-   */ | string
-  /**
-   * If object, configures Cache-Control directives.
-   */ | {
-    /**
-     * Indicates that the response may be cached by any cache.
-     */
-    public?: boolean;
-    /**
-     * Indicates that the response is intended for a single user and must not be stored by a shared cache.
-     */
-    private?: boolean;
-    /**
-     * Forces caches to submit the request to the origin server for validation before releasing a cached copy.
-     */
-    noCache?: boolean;
-    /**
-     * Instructs caches not to store the response.
-     */
-    noStore?: boolean;
-    /**
-     * Maximum amount of time a resource is considered fresh.
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     *
-     * @example 300 // 5 minutes in seconds
-     * @example { minutes: 5 } // 5 minutes
-     * @example { hours: 1 } // 1 hour
-     */
-    maxAge?: number | DurationLike;
-    /**
-     * Overrides max-age for shared caches (e.g., CDNs).
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     */
-    sMaxAge?: number | DurationLike;
-    /**
-     * Indicates that once a resource becomes stale, caches must not use it without successful validation.
-     */
-    mustRevalidate?: boolean;
-    /**
-     * Similar to must-revalidate, but only for shared caches.
-     */
-    proxyRevalidate?: boolean;
-    /**
-     * Indicates that the response can be stored but must be revalidated before each use.
-     */
-    immutable?: boolean;
-  };
-};
-//#endregion
-//#region src/core/components/ClientOnly.d.ts
-interface ClientOnlyProps {
-  fallback?: ReactNode;
-  disabled?: boolean;
-}
-//#endregion
-//#region src/core/errors/Redirection.d.ts
-/**
- * Used for Redirection during the page loading.
- *
- * Depends on the context, it can be thrown or just returned.
- */
-declare class Redirection extends Error {
-  readonly redirect: string;
-  constructor(redirect: string);
-}
-//#endregion
-//#region src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$3: alepha93.TObject<{
-  REACT_STRICT_MODE: alepha93.TBoolean;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$3>> {}
-}
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
-  children?: PageRouteEntry[];
-}
-interface PageRoute extends PageRouteEntry {
-  type: "page";
-  name: string;
-  parent?: PageRoute;
-  match: string;
-}
-interface Layer {
-  config?: {
-    query?: Record<string, any>;
-    params?: Record<string, any>;
-    context?: Record<string, any>;
-  };
-  name: string;
-  props?: Record<string, any>;
-  error?: Error;
-  part?: string;
-  element: ReactNode;
-  index: number;
-  path: string;
-  route?: PageRoute;
-  cache?: boolean;
-}
-type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
-interface ReactRouterState {
-  /**
-   * Stack of layers for the current page.
-   */
-  layers: Array<Layer>;
-  /**
-   * URL of the current page.
-   */
-  url: URL;
-  /**
-   * Error handler for the current page.
-   */
-  onError: ErrorHandler;
-  /**
-   * Params extracted from the URL for the current page.
-   */
-  params: Record<string, any>;
-  /**
-   * Query parameters extracted from the URL for the current page.
-   */
-  query: Record<string, string>;
-  /**
-   * Optional meta information associated with the current page.
-   */
-  meta: Record<string, any>;
-}
-//#endregion
-//#region src/core/services/ReactPageService.d.ts
-declare class ReactPageService {
-  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
-    html: string;
-    response: Response;
-  }>;
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-}
-//#endregion
-//#region src/core/descriptors/$page.d.ts
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-  /**
-   * Identifier name for the page. Must be unique.
-   *
-   * @default Descriptor key
-   */
-  name?: string;
-  /**
-   * Add a pathname to the page.
-   *
-   * Pathname can contain parameters, like `/post/:slug`.
-   *
-   * @default ""
-   */
-  path?: string;
-  /**
-   * Add an input schema to define:
-   * - `params`: parameters from the pathname.
-   * - `query`: query parameters from the URL.
-   */
-  schema?: TConfig;
-  /**
-   * Load data before rendering the page.
-   *
-   * This function receives
-   * - the request context and
-   * - the parent props (if page has a parent)
-   *
-   * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
-   *
-   * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
-   * It's common to throw a `NotFoundError` to display a 404 page.
-   *
-   * RedirectError can be thrown to redirect the user to another page.
-   */
-  resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
-  /**
-   * The component to render when the page is loaded.
-   *
-   * If `lazy` is defined, this will be ignored.
-   * Prefer using `lazy` to improve the initial loading time.
-   */
-  component?: FC<TProps & TPropsParent>;
-  /**
-   * Lazy load the component when the page is loaded.
-   *
-   * It's recommended to use this for components to improve the initial loading time
-   * and enable code-splitting.
-   */
-  lazy?: () => Promise<{
-    default: FC<TProps & TPropsParent>;
-  }>;
-  /**
-   * Attach child pages to create nested routes.
-   * This will make the page a parent route.
-   */
-  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
-  /**
-   * Define a parent page for nested routing.
-   */
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
-  can?: () => boolean;
-  /**
-   * Catch any error from the `resolve` function or during `rendering`.
-   *
-   * Expected to return one of the following:
-   * - a ReactNode to render an error page
-   * - a Redirection to redirect the user
-   * - undefined to let the error propagate
-   *
-   * If not defined, the error will be thrown and handled by the server or client error handler.
-   * If a leaf $page does not define an error handler, the error can be caught by parent pages.
-   *
-   * @example Catch a 404 from API and render a custom not found component:
-   * ```ts
-   * resolve: async ({ params, query }) => {
-   *    api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 404)) {
-   *     return <ResourceNotFound />;
-   *   }
-   * }
-   * ```
-   *
-   * @example Catch an 401 error and redirect the user to the login page:
-   * ```ts
-   * resolve: async ({ params, query }) => {
-   *   // but the user is not authenticated
-   *   api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 401)) {
-   *     // throwing a Redirection is also valid!
-   *     return new Redirection("/login");
-   *   }
-   * }
-   * ```
-   */
-  errorHandler?: ErrorHandler;
-  /**
-   * If true, the page will be considered as a static page, immutable and cacheable.
-   * Replace boolean by an object to define static entries. (e.g. list of params/query)
-   *
-   * Browser-side: it only works with `alepha/vite`, which can pre-render the page at build time.
-   *
-   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
-   */
-  static?: boolean | {
-    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
-  };
-  cache?: ServerRouteCache;
-  /**
-   * If true, force the page to be rendered only on the client-side (browser).
-   * It uses the `<ClientOnly/>` component to render the page.
-   */
-  client?: boolean | ClientOnlyProps;
-  /**
-   * Called before the server response is sent to the client. (server only)
-   */
-  onServerResponse?: (request: ServerRequest) => unknown;
-  /**
-   * Called when user leaves the page. (browser only)
-   */
-  onLeave?: () => void;
-  /**
-   * @experimental
-   *
-   * Add a css animation when the page is loaded or unloaded.
-   * It uses CSS animations, so you need to define the keyframes in your CSS.
-   *
-   * @example Simple animation name
-   * ```ts
-   * animation: "fadeIn"
-   * ```
-   *
-   * CSS example:
-   * ```css
-   * @keyframes fadeIn {
-   *  from { opacity: 0; }
-   *  to { opacity: 1; }
-   * }
-   * ```
-   *
-   * @example Detailed animation
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300 },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
-   *
-   * @example Only exit animation
-   * ```ts
-   * animation: {
-   *   exit: "fadeOut"
-   * }
-   * ```
-   *
-   * @example With custom timing function
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
-   */
-  animation?: PageAnimation;
-}
-type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
-declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
-  protected readonly reactPageService: ReactPageService;
-  protected onInit(): void;
-  get name(): string;
-  /**
-   * For testing or build purposes.
-   *
-   * This will render the page (HTML layout included or not) and return the HTML + context.
-   * Only valid for server-side rendering, it will throw an error if called on the client-side.
-   */
-  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-  fetch(options?: PageDescriptorRenderOptions): Promise<{
-    html: string;
-    response: Response;
-  }>;
-  match(url: string): boolean;
-  pathname(config: any): string;
-}
-interface PageConfigSchema {
-  query?: TSchema;
-  params?: TSchema;
-}
-type TPropsDefault = any;
-type TPropsParentDefault = {};
-interface PageDescriptorRenderOptions {
-  params?: Record<string, string>;
-  query?: Record<string, string>;
-  /**
-   * If true, the HTML layout will be included in the response.
-   * If false, only the page content will be returned.
-   *
-   * @default true
-   */
-  html?: boolean;
-  hydration?: boolean;
-}
-interface PageDescriptorRenderResult {
-  html: string;
-  state: ReactRouterState;
-  redirect?: string;
-}
-interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
-}
-type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
-type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
-type PageAnimationObject = CssAnimationName | {
-  enter?: CssAnimation | CssAnimationName;
-  exit?: CssAnimation | CssAnimationName;
-};
-type CssAnimationName = string;
-type CssAnimation = {
-  name: string;
-  duration?: number;
-  timing?: string;
-};
-//#endregion
-//#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha93.TObject<{
-  id: alepha93.TString;
-  name: alepha93.TOptional<alepha93.TString>;
-  email: alepha93.TOptional<alepha93.TString>;
-  username: alepha93.TOptional<alepha93.TString>;
-  picture: alepha93.TOptional<alepha93.TString>;
-  sessionId: alepha93.TOptional<alepha93.TString>;
-  organizations: alepha93.TOptional<alepha93.TArray<alepha93.TString>>;
-  roles: alepha93.TOptional<alepha93.TArray<alepha93.TString>>;
-}>;
-type UserAccount = Static<typeof userAccountInfoSchema>;
-//#endregion
-//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
-/**
- * Add contextual metadata to a user account info.
- * E.g. UserAccountToken is a UserAccountInfo during a request.
- */
-interface UserAccountToken extends UserAccount {
-  /**
-   * Access token for the user.
-   */
-  token?: string;
-  /**
-   * Realm name of the user.
-   */
-  realm?: string;
-  /**
-   * Is user dedicated to his own resources for this scope ?
-   * Mostly, Admin is false and Customer is true.
-   */
-  ownership?: string | boolean;
-}
-//#endregion
-//#region ../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema$2: alepha93.TObject<{
-  APP_SECRET: alepha93.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
-}
-//#endregion
-//#region ../alepha/src/security/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    "security:user:created": {
-      realm: string;
-      user: UserAccount;
-    };
-  }
-}
-/**
- * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
- *
- * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
- * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
- * integration with various authentication providers and user management systems.
- *
- * @see {@link $realm}
- * @see {@link $role}
- * @see {@link $permission}
- * @module alepha.security
- */
-//#endregion
-//#region ../alepha/src/server-security/providers/ServerBasicAuthProvider.d.ts
-interface BasicAuthOptions {
-  username: string;
-  password: string;
-}
-//#endregion
-//#region ../alepha/src/server-security/providers/ServerSecurityProvider.d.ts
-type ServerRouteSecure = {
-  realm?: string;
-  basic?: BasicAuthOptions;
-};
-//#endregion
-//#region ../alepha/src/server-security/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * Real (or fake) user account, used for internal actions.
-     *
-     * If you define this, you assume that all actions are executed by this user by default.
-     * > To force a different user, you need to pass it explicitly in the options.
-     */
-    "alepha.server.security.system.user"?: UserAccountToken;
-    /**
-     * The authenticated user account attached to the server request state.
-     *
-     * @internal
-     */
-    "alepha.server.request.user"?: UserAccount;
-  }
-}
-declare module "alepha/server" {
-  interface ServerRequest<TConfig> {
-    user?: UserAccountToken;
-  }
-  interface ServerActionRequest<TConfig> {
-    user: UserAccountToken;
-  }
-  interface ServerRoute {
-    /**
-     * If true, the route will be protected by the security provider.
-     * All actions are secure by default, but you can disable it for specific actions.
-     */
-    secure?: boolean | ServerRouteSecure;
-  }
-  interface ClientRequestOptions extends FetchOptions {
-    /**
-     * Forward user from the previous request.
-     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-     * If "context", use the user from the current context (e.g. request).
-     *
-     * @default "system" if provided, else "context" if available.
-     */
-    user?: UserAccountToken | "system" | "context";
-  }
-}
-/**
- * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
- *
- * By default, all $action will be guarded by a permission check.
- *
- * @see {@link ServerSecurityProvider}
- * @module alepha.server.security
- */
-//#endregion
-//#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinksResponseSchema: alepha93.TObject<{
-  prefix: alepha93.TOptional<alepha93.TString>;
-  links: alepha93.TArray<alepha93.TObject<{
-    name: alepha93.TString;
-    group: alepha93.TOptional<alepha93.TString>;
-    path: alepha93.TString;
-    method: alepha93.TOptional<alepha93.TString>;
-    requestBodyType: alepha93.TOptional<alepha93.TString>;
-    service: alepha93.TOptional<alepha93.TString>;
-  }>>;
-}>;
-type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
-//#endregion
-//#region ../alepha/src/server-links/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * API links attached to the server request state.
-     *
-     * @see {@link ApiLinksResponse}
-     * @internal
-     */
-    "alepha.server.request.apiLinks"?: ApiLinksResponse;
-  }
-}
-/**
- * Provides server-side link management and remote capabilities for client-server interactions.
- *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
- * facilitating seamless API endpoint management and client-server communication. It integrates with server
- * security features to ensure safe and controlled access to resources.
- *
- * @see {@link $remote}
- * @see {@link $client}
- * @module alepha.server.links
- */
-//#endregion
-//#region src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: alepha93.TObject<{
-  REACT_ROOT_ID: alepha93.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-/**
- * React browser renderer configuration atom
- */
-declare const reactBrowserOptions: alepha93.Atom<alepha93.TObject<{
-  scrollRestoration: alepha93.TUnsafe<"top" | "manual">;
-}>, "alepha.react.browser.options">;
-type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactBrowserOptions.key]: ReactBrowserRendererOptions;
-  }
-}
-type ReactHydrationState = {
-  layers?: Array<PreviousLayerData>;
-} & {
-  [key: string]: any;
-};
-//#endregion
-//#region src/core/providers/ReactServerProvider.d.ts
-declare const envSchema: alepha93.TObject<{
-  REACT_SSR_ENABLED: alepha93.TOptional<alepha93.TBoolean>;
-  REACT_ROOT_ID: alepha93.TString;
-  REACT_SERVER_TEMPLATE: alepha93.TOptional<alepha93.TString>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-  interface State {
-    "alepha.react.server.ssr"?: boolean;
-  }
-}
-/**
- * React server provider configuration atom
- */
-declare const reactServerOptions: alepha93.Atom<alepha93.TObject<{
-  publicDir: alepha93.TString;
-  staticServer: alepha93.TObject<{
-    disabled: alepha93.TBoolean;
-    path: alepha93.TString;
-  }>;
-}>, "alepha.react.server.options">;
-type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactServerOptions.key]: ReactServerProviderOptions;
-  }
-}
-//#endregion
-//#region src/core/index.d.ts
-declare module "alepha" {
-  interface State {
-    "alepha.react.router.state"?: ReactRouterState;
-  }
-  interface Hooks {
-    /**
-     * Fires when the React application is starting to be rendered on the server.
-     */
-    "react:server:render:begin": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-    };
-    /**
-     * Fires when the React application has been rendered on the server.
-     */
-    "react:server:render:end": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-      html: string;
-    };
-    /**
-     * Fires when the React application is being rendered on the browser.
-     */
-    "react:browser:render": {
-      root: HTMLElement;
-      element: ReactNode;
-      state: ReactRouterState;
-      hydration?: ReactHydrationState;
-    };
-    /**
-     * 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;
-    };
-    /**
-     * Fires when a route transition is starting.
-     */
-    "react:transition:begin": {
-      previous: ReactRouterState;
-      state: ReactRouterState;
-      animation?: PageAnimation;
-    };
-    /**
-     * Fires when a route transition has succeeded.
-     */
-    "react:transition:success": {
-      state: ReactRouterState;
-    };
-    /**
-     * Fires when a route transition has failed.
-     */
-    "react:transition:error": {
-      state: ReactRouterState;
-      error: Error;
-    };
-    /**
-     * Fires when a route transition has completed, regardless of success or failure.
-     */
-    "react:transition:end": {
-      state: ReactRouterState;
-    };
-  }
-}
-/**
- * Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
- *
- * The React module enables building modern React applications using the `$page` descriptor on class properties.
- * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
- * type safety and schema validation for route parameters and data.
- *
- * @see {@link $page}
- * @module alepha.react
- */
-//#endregion
-//#region src/head/interfaces/Head.d.ts
-interface Head extends SimpleHead {
-  description?: string;
-  keywords?: string[];
-  author?: string;
-  robots?: string;
-  themeColor?: string;
-  viewport?: string | {
-    width?: string;
-    height?: string;
-    initialScale?: string;
-    maximumScale?: string;
-    userScalable?: "no" | "yes" | "0" | "1";
-    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
-  };
-  og?: {
-    title?: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-  };
-  twitter?: {
-    card?: string;
-    title?: string;
-    description?: string;
-    image?: string;
-    site?: string;
-  };
-}
-interface SimpleHead {
-  title?: string;
-  titleSeparator?: string;
-  htmlAttributes?: Record<string, string>;
-  bodyAttributes?: Record<string, string>;
-  meta?: Array<{
-    name: string;
-    content: string;
-  }>;
-}
-//#endregion
-//#region src/head/providers/HeadProvider.d.ts
-declare class HeadProvider {
-  global?: Head | (() => Head);
-  protected getGlobalHead(): Head | undefined;
-  fillHead(state: ReactRouterState): void;
-  protected fillHeadByPage(page: PageRoute, state: ReactRouterState, props: Record<string, any>): void;
-}
-//#endregion
-//#region src/head/descriptors/$head.d.ts
-/**
- * Set global `<head>` options for the application.
- */
-declare const $head: {
-  (options: HeadDescriptorOptions): HeadDescriptor;
-  [KIND]: typeof HeadDescriptor;
-};
-type HeadDescriptorOptions = Head | (() => Head);
-declare class HeadDescriptor extends Descriptor<HeadDescriptorOptions> {
-  protected readonly provider: HeadProvider;
-  protected onInit(): void;
-}
-//#endregion
-//#region src/head/hooks/useHead.d.ts
-/**
- * ```tsx
- * const App = () => {
- *   const [head, setHead] = useHead({
- *     // will set the document title on the first render
- *     title: "My App",
- *   });
- *
- *   return (
- *     // This will update the document title when the button is clicked
- *     <button onClick={() => setHead({ title: "Change Title" })}>
- *       Change Title {head.title}
- *     </button>
- *   );
- * }
- * ```
- */
-declare const useHead: (options?: UseHeadOptions) => UseHeadReturn;
-type UseHeadOptions = Head | ((previous?: Head) => Head);
-type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
-//#endregion
 //#region src/head/providers/ServerHeadProvider.d.ts
 declare class ServerHeadProvider {
   protected readonly headProvider: HeadProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly onServerRenderEnd: alepha93.HookDescriptor<"react:server:render:end">;
+  protected readonly onServerRenderEnd: alepha53.HookDescriptor<"react:server:render:end">;
   renderHead(template: string, head: SimpleHead): string;
   protected mergeAttributes(existing: string, attrs: Record<string, string>): string;
   protected parseAttributes(attrStr: string): Record<string, string>;
@@ -1796,7 +1060,7 @@ declare module "@alepha/react" {
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
  */
-declare const AlephaReactHead: alepha93.Service<alepha93.Module>;
+declare const AlephaReactHead: alepha53.Service<alepha53.Module>;
 //#endregion
 export { $head, AlephaReactHead, Head, HeadDescriptor, HeadDescriptorOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
 //# sourceMappingURL=index.d.ts.map