@alepha/react 0.6.1 → 0.6.2

package/dist/index.browser.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var core = require('@alepha/core');
-var useAuth = require('./useAuth-DOVx2kqa.cjs');
+var useAuth = require('./useAuth-B9ypF48n.cjs');
 require('react/jsx-runtime');
 require('react');
 require('@alepha/server');

package/dist/index.browser.js

@@ -1,6 +1,6 @@
 import { autoInject, $inject, Alepha } from '@alepha/core';
-import { a as $page, P as PageDescriptorProvider, l as ReactBrowserProvider, A as Auth } from './useAuth-i7wbKVrt.js';
-export { $ as $auth, L as Link, N as NestedView, R as Router, b as RouterContext, d as RouterHookApi, c as RouterLayerContext, p as pageDescriptorKey, j as useActive, k as useAuth, e as useClient, u as useInject, f as useQueryParams, g as useRouter, h as useRouterEvents, i as useRouterState } from './useAuth-i7wbKVrt.js';
+import { a as $page, P as PageDescriptorProvider, l as ReactBrowserProvider, A as Auth } from './useAuth-Ps01oe8e.js';
+export { $ as $auth, L as Link, N as NestedView, R as Router, b as RouterContext, d as RouterHookApi, c as RouterLayerContext, p as pageDescriptorKey, j as useActive, k as useAuth, e as useClient, u as useInject, f as useQueryParams, g as useRouter, h as useRouterEvents, i as useRouterState } from './useAuth-Ps01oe8e.js';
 import 'react/jsx-runtime';
 import 'react';
 import '@alepha/server';

package/dist/index.cjs

@@ -2,11 +2,12 @@
 
 var core = require('@alepha/core');
 var server = require('@alepha/server');
-var useAuth = require('./useAuth-DOVx2kqa.cjs');
+var useAuth = require('./useAuth-B9ypF48n.cjs');
 var openidClient = require('openid-client');
 var node_fs = require('node:fs');
 var promises = require('node:fs/promises');
 var node_path = require('node:path');
+var cheerio = require('cheerio');
 var server$1 = require('react-dom/server');
 require('react/jsx-runtime');
 require('react');
@@ -16,7 +17,7 @@ require('path-to-regexp');
 class ReactAuthProvider {
   log = core.$logger();
   alepha = core.$inject(core.Alepha);
-  fastifyCookieProvider = core.$inject(server.FastifyCookieProvider);
+  serverCookieProvider = core.$inject(server.ServerCookieProvider);
   authProviders = [];
   authorizationCode = server.$cookie({
     name: "authorizationCode",
@@ -54,23 +55,30 @@ class ReactAuthProvider {
     name: "configure",
     handler: async () => {
       const auths = this.alepha.getDescriptorValues(useAuth.$auth);
-      for (const auth of auths) {
-        const options = auth.value.options;
+      for (const { value, key, instance } of auths) {
+        const options = value.options;
         if (options.oidc) {
+          this.log.debug(
+            `Discover OIDC auth provider -> ${options.oidc.issuer}`
+          );
+          const client = await openidClient.discovery(
+            new URL(options.oidc.issuer),
+            options.oidc.clientId,
+            {
+              client_secret: options.oidc.clientSecret
+            },
+            void 0,
+            {
+              execute: [openidClient.allowInsecureRequests]
+            }
+          );
+          instance[key].jwks = () => {
+            return client.serverMetadata().jwks_uri;
+          };
           this.authProviders.push({
-            name: options.name ?? auth.key,
+            name: options.name ?? key,
             redirectUri: options.oidc.redirectUri ?? "/api/_oauth/callback",
-            client: await openidClient.discovery(
-              new URL(options.oidc.issuer),
-              options.oidc.clientId,
-              {
-                client_secret: options.oidc.clientSecret
-              },
-              void 0,
-              {
-                execute: [openidClient.allowInsecureRequests]
-              }
-            )
+            client
           });
         }
       }
@@ -79,21 +87,19 @@ class ReactAuthProvider {
   /**
    * Configure Fastify to forward Session Access Token to Header Authorization.
    */
-  configureFastify = core.$hook({
-    name: "configure:fastify",
-    after: this.fastifyCookieProvider,
-    handler: async (app) => {
-      app.addHook("onRequest", async (req) => {
-        if (req.cookies && !this.isViteFile(req.url) && !!this.authProviders.length) {
-          const tokens = await this.refresh(req.cookies);
-          if (tokens) {
-            req.headers.authorization = `Bearer ${tokens.access_token}`;
-          }
-          if (this.user.get(req.cookies) && !this.tokens.get(req.cookies)) {
-            this.user.del(req.cookies);
-          }
+  onRequest = core.$hook({
+    name: "server:onRequest",
+    after: this.serverCookieProvider,
+    handler: async ({ request }) => {
+      if (request.cookies && !this.isViteFile(request.url.pathname) && !!this.authProviders.length) {
+        const tokens = await this.refresh(request.cookies);
+        if (tokens) {
+          request.headers.rep("authorization", `Bearer ${tokens.access_token}`);
         }
-      });
+        if (this.user.get(request.cookies) && !this.tokens.get(request.cookies)) {
+          this.user.del(request.cookies);
+        }
+      }
     }
   });
   /**
@@ -122,7 +128,9 @@ class ReactAuthProvider {
             });
             return newTokens;
           } catch (e) {
-            this.log.warn(e, "Failed to refresh token -");
+            if (e instanceof Error) {
+              this.log.warn("Failed to refresh token", e.message);
+            }
           }
         }
         this.tokens.del(cookies);
@@ -316,13 +324,13 @@ const envSchema$1 = core.t.object({
   REACT_SERVER_DIST: core.t.string({ default: "client" }),
   REACT_SERVER_PREFIX: core.t.string({ default: "" }),
   REACT_SSR_ENABLED: core.t.boolean({ default: false }),
-  REACT_SSR_OUTLET: core.t.string({ default: "<!--ssr-outlet-->" })
+  REACT_ROOT_ID: core.t.string({ default: "root" })
 });
 class ReactServerProvider {
   log = core.$logger();
   alepha = core.$inject(core.Alepha);
   router = core.$inject(useAuth.Router);
-  server = core.$inject(server.ServerProvider);
+  serverProvider = core.$inject(server.ServerProvider);
   env = core.$inject(envSchema$1);
   configure = core.$hook({
     name: "configure",
@@ -330,7 +338,9 @@ class ReactServerProvider {
       await this.configureRoutes();
     }
   });
+  id = Math.random().toString(36).substring(2, 7);
   async configureRoutes() {
+    this.alepha.state("ReactServerProvider.ssr", false);
     if (this.alepha.isTest()) {
       this.processDescriptors();
     }
@@ -338,14 +348,15 @@ class ReactServerProvider {
       return;
     }
     if (process.env.VITE_ALEPHA_DEV === "true") {
+      const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
       this.log.info("SSR (vite) OK");
-      const templateUrl = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}/index.html`;
-      this.log.debug(`Fetch template from ${templateUrl}`);
+      this.alepha.state("ReactServerProvider.ssr", true);
+      const templateUrl = `${url}/index.html`;
       const route2 = this.createHandler(
-        () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0).then((it) => it ? this.checkTemplate(it) : void 0)
+        () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0)
       );
-      await this.server.route(route2);
-      await this.server.route({
+      await this.serverProvider.route(route2);
+      await this.serverProvider.route({
         ...route2,
         url: "*"
       });
@@ -367,37 +378,16 @@ class ReactServerProvider {
         this.log.warn("Missing static files, SSR will be disabled");
         return;
       }
-      await this.server.serve(this.createStaticHandler(root));
+      await this.serverProvider.serve(this.createStaticHandler(root));
     }
-    const template = this.checkTemplate(
-      this.alepha.state("ReactServerProvider.template") ?? await promises.readFile(node_path.join(root, "index.html"), "utf-8")
-    );
+    const template = this.alepha.state("ReactServerProvider.template") ?? await promises.readFile(node_path.join(root, "index.html"), "utf-8");
     const route = this.createHandler(async () => template);
-    await this.server.route(route);
-    await this.server.route({
+    await this.serverProvider.route(route);
+    await this.serverProvider.route({
       ...route,
       url: "*"
     });
-  }
-  /**
-   * Check if the template contains the outlet.
-   *
-   * @param template
-   * @protected
-   */
-  checkTemplate(template) {
-    if (!template.includes(this.env.REACT_SSR_OUTLET)) {
-      if (!template.includes('<div id="root"></div>')) {
-        throw new Error(
-          `Missing React SSR outlet in index.html, please add ${this.env.REACT_SSR_OUTLET} to the index.html file`
-        );
-      }
-      return template.replace(
-        `<div id="root"></div>`,
-        `<div id="root">${this.env.REACT_SSR_OUTLET}</div>`
-      );
-    }
-    return template;
+    this.alepha.state("ReactServerProvider.ssr", true);
   }
   /**
    *
@@ -438,6 +428,10 @@ class ReactServerProvider {
       }
     };
   }
+  /**
+   *
+   * @protected
+   */
   processDescriptors() {
     const pages = this.alepha.getDescriptorValues(useAuth.$page);
     for (const { key, instance, value } of pages) {
@@ -478,7 +472,20 @@ class ReactServerProvider {
    * @param template
    * @param args
    */
-  async ssr(url, template = this.env.REACT_SSR_OUTLET, args = {}) {
+  async ssr(url, template, args = {}) {
+    const hasAuth = this.alepha.has(ReactAuthProvider);
+    if (!args.user && args.cookies && hasAuth) {
+      const auth = this.alepha.get(ReactAuthProvider);
+      args.user = auth.user.get(args.cookies);
+      if (args.user) {
+        args.user.roles = [];
+      }
+    }
+    if (this.alepha.has(server.ServerLinksProvider) && hasAuth) {
+      const srv = this.alepha.get(server.ServerLinksProvider);
+      args.links = await srv.links();
+      this.alepha.als.set("links", args.links);
+    }
     const { element, layers, redirect, context } = await this.router.render(
       url.pathname + url.search,
       {
@@ -493,42 +500,67 @@ class ReactServerProvider {
         }
       });
     }
-    const appHtml = server$1.renderToString(element);
+    const html = server$1.renderToString(element);
+    const $ = cheerio.load(template);
     const script = `<script>window.__ssr=${JSON.stringify({
+      links: args.links,
       layers: layers.map((it) => ({
         ...it,
+        error: it.error ? {
+          ...it.error,
+          name: it.error.name,
+          message: it.error.message,
+          stack: it.error.stack
+          // TODO: Hide stack in production ?
+        } : void 0,
         index: void 0,
         path: void 0,
         element: void 0
       }))
     })}<\/script>`;
-    const index = template.indexOf("</body>");
-    if (index !== -1) {
-      template = template.slice(0, index) + script + template.slice(index);
+    const body = $("body");
+    const root = body.find(`#${this.env.REACT_ROOT_ID}`);
+    if (root.length) {
+      root.html(html);
+    } else {
+      body.prepend(`<div id="${this.env.REACT_ROOT_ID}">${html}</div>`);
     }
-    if (context.helmet) {
-      template = this.renderHelmetContext(template, context.helmet);
+    body.append(script);
+    if (context.head) {
+      this.renderHeadContext($, context.head);
     }
-    template = template.replace(this.env.REACT_SSR_OUTLET, appHtml);
-    return new Response(template, {
+    return new Response($.html(), {
       headers: { "Content-Type": "text/html" }
     });
   }
-  renderHelmetContext(template, helmetContext) {
-    if (helmetContext.title) {
-      if (template.includes("<title>")) {
-        template = template.replace(
-          /<title>.*<\/title>/,
-          `<title>${helmetContext.title}</title>`
-        );
-      } else {
-        template = template.replace(
-          "</head>",
-          `<title>${helmetContext.title}</title></head>`
-        );
+  renderHeadContext($, headContext) {
+    const head = $("head");
+    if (head) {
+      if (headContext.title) {
+        head.find("title").remove();
+        head.append(`<title>${headContext.title}</title>`);
+      }
+      if (headContext.meta) {
+        for (const it of headContext.meta) {
+          const meta = head.find(`meta[name="${it.name}"]`);
+          if (meta.length) {
+            meta.attr("content", it.content);
+          } else {
+            head.append(`<meta name="${it.name}" content="${it.content}" />`);
+          }
+        }
+      }
+    }
+    if (headContext.htmlAttributes) {
+      for (const [key, value] of Object.entries(headContext.htmlAttributes)) {
+        $("html").attr(key, value);
+      }
+    }
+    if (headContext.bodyAttributes) {
+      for (const [key, value] of Object.entries(headContext.bodyAttributes)) {
+        $("body").attr(key, value);
       }
     }
-    return template;
   }
 }
 

package/dist/index.d.ts

@@ -1,14 +1,15 @@
 import * as _alepha_core from '@alepha/core';
-import { EventEmitter, Alepha, TSchema as TSchema$1, Static as Static$1, Async, KIND, Class, TObject as TObject$1 } from '@alepha/core';
+import { EventEmitter, Alepha, Static as Static$1, TSchema as TSchema$1, KIND, Async, Class, TObject as TObject$1 } from '@alepha/core';
 import * as react from 'react';
-import react__default, { ReactNode, AnchorHTMLAttributes, FC } from 'react';
+import react__default, { ReactNode, FC, AnchorHTMLAttributes } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { UserAccountToken } from '@alepha/security';
 import * as _alepha_server from '@alepha/server';
-import { FastifyCookieProvider, CookieManager, HttpClient, ServerProvider, ServeDescriptorOptions, CreateRoute } from '@alepha/server';
+import { HttpLink, ServerCookieProvider, CookieManager, HttpClient, ServerProvider, ServeDescriptorOptions, RouteObject } from '@alepha/server';
 import { Root } from 'react-dom/client';
 import { MatchFunction, ParamData } from 'path-to-regexp';
 import { Configuration } from 'openid-client';
+import { CheerioAPI } from 'cheerio';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -149,13 +150,7 @@ interface NestedViewProps {
  * @param props
  * @constructor
  */
-declare const NestedView: (props: NestedViewProps) => string | number | boolean | react.ReactElement<any, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null;
-
-interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    to: string;
-    children?: react__default.ReactNode;
-}
-declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element;
+declare const NestedView: (props: NestedViewProps) => string | number | bigint | boolean | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
 
 declare class Router extends EventEmitter<RouterEvents> {
     protected readonly log: _alepha_core.Logger;
@@ -348,6 +343,10 @@ interface Layer {
      *
      */
     props?: Record<string, any>;
+    /**
+     *
+     */
+    error?: Error;
     /**
      *
      */
@@ -430,7 +429,7 @@ interface RouterRenderContext {
     /**
      *
      */
-    helmet?: RouterRenderHelmetContext;
+    head?: RouterRenderHeadContext;
 }
 interface RouterRenderOptions extends RouterMatchOptions {
     /**
@@ -456,7 +455,7 @@ interface RouterStackItem {
      */
     error?: Error;
 }
-interface RouterRenderHelmetContext {
+interface RouterRenderHeadContext {
     /**
      *
      */
@@ -464,15 +463,15 @@ interface RouterRenderHelmetContext {
     /**
      *
      */
-    html?: {
-        attributes?: Record<string, string>;
-    };
+    titleSeparator?: string;
     /**
-     *
+     * Add html attributes to the <html> tag.
      */
-    body?: {
-        attributes?: Record<string, string>;
-    };
+    htmlAttributes?: Record<string, string>;
+    /**
+     * Add html attributes to the <body> tag.
+     */
+    bodyAttributes?: Record<string, string>;
     /**
      *
      */
@@ -503,7 +502,7 @@ interface RouterRenderResult {
 declare class ReactAuthProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
-    protected readonly fastifyCookieProvider: FastifyCookieProvider;
+    protected readonly serverCookieProvider: ServerCookieProvider;
     protected authProviders: AuthProvider[];
     protected readonly authorizationCode: _alepha_server.CookieDescriptor<TObject<{
         codeVerifier: TOptional<TString>;
@@ -517,7 +516,7 @@ declare class ReactAuthProvider {
         scope: TOptional<TString>;
         issued_at: TOptional<TNumber>;
     }>>;
-    protected readonly user: _alepha_server.CookieDescriptor<TObject<{
+    readonly user: _alepha_server.CookieDescriptor<TObject<{
         id: TString;
         name: TOptional<TString>;
         email: TOptional<TString>;
@@ -526,7 +525,7 @@ declare class ReactAuthProvider {
     /**
      * Configure Fastify to forward Session Access Token to Header Authorization.
      */
-    protected readonly configureFastify: _alepha_core.HookDescriptor<"configure:fastify">;
+    protected readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
     /**
      *
      * @param cookies
@@ -611,12 +610,23 @@ interface ReactHydrationState {
     user?: ReactUser;
     auth?: "server" | "client";
     layers?: PreviousLayerData[];
+    links?: HttpLink[];
 }
 
+declare const envSchema$2: _alepha_core.TObject<{
+    REACT_ROOT_ID: TString;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema$2>> {
+    }
+}
 declare class ReactBrowserProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly client: HttpClient;
     protected readonly router: Router;
+    protected readonly env: {
+        REACT_ROOT_ID: string;
+    };
     protected root: Root;
     transitioning?: {
         to: string;
@@ -655,8 +665,15 @@ declare class ReactBrowserProvider {
         previous?: PreviousLayerData[];
     }): Promise<{
         url: string;
+        context: RouterRenderContext;
     }>;
-    protected renderHelmetContext(ctx: RouterRenderHelmetContext): void;
+    /**
+     * Render the helmet context.
+     *
+     * @param ctx
+     * @protected
+     */
+    protected renderHeadContext(ctx: RouterRenderHeadContext): void;
     /**
      * Get embedded layers from the server.
      *
@@ -674,11 +691,6 @@ declare class ReactBrowserProvider {
      * @protected
      */
     protected ready: _alepha_core.HookDescriptor<"ready">;
-    /**
-     *
-     * @protected
-     */
-    protected stop: _alepha_core.HookDescriptor<"stop">;
 }
 /**
  *
@@ -815,12 +827,16 @@ interface PageDescriptorOptions<TConfig extends PageDescriptorConfigSchema = Pag
     /**
      *
      */
-    helmet?: RouterRenderHelmetContext | ((props: TProps) => RouterRenderHelmetContext);
+    can?: () => boolean;
+    /**
+     *
+     */
+    head?: RouterRenderHeadContext | ((props: TProps, previous?: RouterRenderHeadContext) => RouterRenderHeadContext);
     /**
      *
      */
     notFoundHandler?: FC<{
-        error: Error;
+        url: string;
     }>;
     /**
      *
@@ -833,6 +849,7 @@ interface PageDescriptorOptions<TConfig extends PageDescriptorConfigSchema = Pag
 interface PageContext {
     user?: UserAccountToken;
     cookies?: CookieManager;
+    links?: HttpLink[];
 }
 interface PageDescriptorConfigValue<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema> {
     query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
@@ -857,6 +874,12 @@ declare const $page: {
     [KIND]: string;
 };
 
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string | PageDescriptor;
+    children?: react__default.ReactNode;
+}
+declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
+
 interface RouterContextValue {
     router: Router;
     alepha: Alepha;
@@ -875,7 +898,10 @@ declare class Auth {
     alepha: Alepha;
     log: _alepha_core.Logger;
     client: HttpClient;
-    api: string;
+    slugs: {
+        login: string;
+        logout: string;
+    };
     start: _alepha_core.HookDescriptor<"start">;
     login: (provider?: string) => void;
     logout: () => void;
@@ -894,6 +920,7 @@ interface AuthDescriptorOptions {
 interface AuthDescriptor {
     [KIND]: typeof KEY;
     options: AuthDescriptorOptions;
+    jwks: () => string;
 }
 declare const $auth: {
     (options: AuthDescriptorOptions): AuthDescriptor;
@@ -962,47 +989,46 @@ declare const envSchema$1: TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
     REACT_SSR_ENABLED: TBoolean;
-    REACT_SSR_OUTLET: TString;
+    REACT_ROOT_ID: TString;
 }>;
 declare module "@alepha/core" {
     interface Env extends Partial<Static$1<typeof envSchema$1>> {
     }
     interface State {
         "ReactServerProvider.template"?: string;
+        "ReactServerProvider.ssr"?: boolean;
     }
 }
 declare class ReactServerProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly router: Router;
-    protected readonly server: ServerProvider;
+    protected readonly serverProvider: ServerProvider;
     protected readonly env: {
+        REACT_ROOT_ID: string;
         REACT_SERVER_DIST: string;
         REACT_SERVER_PREFIX: string;
         REACT_SSR_ENABLED: boolean;
-        REACT_SSR_OUTLET: string;
     };
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    id: string;
     protected configureRoutes(): Promise<void>;
     /**
-     * Check if the template contains the outlet.
      *
-     * @param template
+     * @param root
      * @protected
      */
-    protected checkTemplate(template: string): string;
+    protected createStaticHandler(root: string): ServeDescriptorOptions;
     /**
      *
-     * @param root
+     * @param templateLoader
      * @protected
      */
-    protected createStaticHandler(root: string): ServeDescriptorOptions;
+    protected createHandler(templateLoader: () => Promise<string | undefined>): RouteObject;
     /**
      *
-     * @param templateLoader
      * @protected
      */
-    protected createHandler(templateLoader: () => Promise<string | undefined>): CreateRoute;
     protected processDescriptors(): void;
     /**
      *
@@ -1016,8 +1042,8 @@ declare class ReactServerProvider {
      * @param template
      * @param args
      */
-    ssr(url: URL, template?: string, args?: PageContext): Promise<Response>;
-    protected renderHelmetContext(template: string, helmetContext: RouterRenderHelmetContext): string;
+    ssr(url: URL, template: string, args?: PageContext): Promise<Response>;
+    protected renderHeadContext($: CheerioAPI, headContext: RouterRenderHeadContext): void;
 }
 
 declare class RedirectionError extends Error {
@@ -1040,4 +1066,4 @@ declare class ReactModule {
     constructor();
 }
 
-export { $auth, $page, type AnchorProps, Auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, type HrefLike, type Layer, Link, NestedView, type PageContext, type PageDescriptor, type PageDescriptorConfigSchema, type PageDescriptorConfigValue, type PageDescriptorOptions, PageDescriptorProvider, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactAuthProvider, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, type ReactUser, RedirectionError, Router, RouterContext, type RouterContextValue, type RouterEvents, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterMatchOptions, type RouterRenderContext, type RouterRenderHelmetContext, type RouterRenderOptions, type RouterRenderResult, type RouterStackItem, type RouterState, type SessionAuthorizationCode, type SessionTokens, type TPropsDefault, type TPropsParentDefault, type UseActiveHook, type UseQueryParamsHookOptions, envSchema$1 as envSchema, pageDescriptorKey, useActive, useAuth, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $auth, $page, type AnchorProps, Auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, type HrefLike, type Layer, Link, NestedView, type PageContext, type PageDescriptor, type PageDescriptorConfigSchema, type PageDescriptorConfigValue, type PageDescriptorOptions, PageDescriptorProvider, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactAuthProvider, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, type ReactUser, RedirectionError, Router, RouterContext, type RouterContextValue, type RouterEvents, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterMatchOptions, type RouterRenderContext, type RouterRenderHeadContext, type RouterRenderOptions, type RouterRenderResult, type RouterStackItem, type RouterState, type SessionAuthorizationCode, type SessionTokens, type TPropsDefault, type TPropsParentDefault, type UseActiveHook, type UseQueryParamsHookOptions, envSchema$1 as envSchema, pageDescriptorKey, useActive, useAuth, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };