@alepha/react 0.6.1 → 0.6.3

package/dist/index.cjs

@@ -2,575 +2,298 @@
 
 var core = require('@alepha/core');
 var server = require('@alepha/server');
-var useAuth = require('./useAuth-DOVx2kqa.cjs');
-var openidClient = require('openid-client');
+var useActive = require('./useActive-BVqdq757.cjs');
 var node_fs = require('node:fs');
 var promises = require('node:fs/promises');
 var node_path = require('node:path');
+var serverStatic = require('@alepha/server-static');
 var server$1 = require('react-dom/server');
 require('react/jsx-runtime');
 require('react');
 require('react-dom/client');
-require('path-to-regexp');
+require('@alepha/router');
 
-class ReactAuthProvider {
-  log = core.$logger();
-  alepha = core.$inject(core.Alepha);
-  fastifyCookieProvider = core.$inject(server.FastifyCookieProvider);
-  authProviders = [];
-  authorizationCode = server.$cookie({
-    name: "authorizationCode",
-    ttl: { minutes: 15 },
-    httpOnly: true,
-    schema: core.t.object({
-      codeVerifier: core.t.optional(core.t.string({ size: "long" })),
-      redirectUri: core.t.optional(core.t.string({ size: "long" }))
-    })
-  });
-  tokens = server.$cookie({
-    name: "tokens",
-    ttl: { days: 1 },
-    httpOnly: true,
-    compress: true,
-    schema: core.t.object({
-      access_token: core.t.optional(core.t.string({ size: "rich" })),
-      expires_in: core.t.optional(core.t.number()),
-      refresh_token: core.t.optional(core.t.string({ size: "rich" })),
-      id_token: core.t.optional(core.t.string({ size: "rich" })),
-      scope: core.t.optional(core.t.string()),
-      issued_at: core.t.optional(core.t.number())
-    })
-  });
-  user = server.$cookie({
-    name: "user",
-    ttl: { days: 1 },
-    schema: core.t.object({
-      id: core.t.string(),
-      name: core.t.optional(core.t.string()),
-      email: core.t.optional(core.t.string())
-    })
-  });
-  configure = core.$hook({
-    name: "configure",
-    handler: async () => {
-      const auths = this.alepha.getDescriptorValues(useAuth.$auth);
-      for (const auth of auths) {
-        const options = auth.value.options;
-        if (options.oidc) {
-          this.authProviders.push({
-            name: options.name ?? auth.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]
-              }
-            )
-          });
-        }
-      }
-    }
-  });
-  /**
-   * 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);
-          }
-        }
-      });
-    }
-  });
-  /**
-   *
-   * @param cookies
-   * @protected
-   */
-  async refresh(cookies) {
-    const now = Date.now();
-    const tokens = this.tokens.get(cookies);
-    if (!tokens) {
-      return;
-    }
-    if (tokens.expires_in && tokens.issued_at) {
-      const expiresAt = tokens.issued_at + (tokens.expires_in - 10) * 1e3;
-      if (expiresAt < now) {
-        if (tokens.refresh_token) {
-          try {
-            const newTokens = await openidClient.refreshTokenGrant(
-              this.authProviders[0].client,
-              tokens.refresh_token
-            );
-            this.tokens.set(cookies, {
-              ...newTokens,
-              issued_at: Date.now()
-            });
-            return newTokens;
-          } catch (e) {
-            this.log.warn(e, "Failed to refresh token -");
-          }
-        }
-        this.tokens.del(cookies);
-        this.user.del(cookies);
-        return;
-      }
-    }
-    if (!tokens.issued_at && tokens.access_token) {
-      this.tokens.del(cookies);
-      this.user.del(cookies);
-      return;
-    }
-    return tokens;
-  }
-  /**
-   *
-   */
-  login = server.$route({
-    security: false,
-    internal: true,
-    url: "/_oauth/login",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: core.t.object({
-        redirect: core.t.optional(core.t.string()),
-        provider: core.t.optional(core.t.string())
-      })
-    },
-    handler: async ({ query, cookies, url }) => {
-      const { client, redirectUri } = this.provider(query.provider);
-      const codeVerifier = openidClient.randomPKCECodeVerifier();
-      const codeChallenge = await openidClient.calculatePKCECodeChallenge(codeVerifier);
-      const scope = "openid profile email";
-      let redirect_uri = redirectUri;
-      if (redirect_uri.startsWith("/")) {
-        redirect_uri = `${url.protocol}//${url.host}${redirect_uri}`;
-      }
-      const parameters = {
-        redirect_uri,
-        scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: "S256"
-      };
-      this.authorizationCode.set(cookies, {
-        codeVerifier,
-        redirectUri: query.redirect ?? "/"
-      });
-      return new Response("", {
-        status: 302,
-        headers: {
-          Location: openidClient.buildAuthorizationUrl(client, parameters).toString()
-        }
-      });
-    }
-  });
-  /**
-   *
-   */
-  callback = server.$route({
-    security: false,
-    internal: true,
-    url: "/_oauth/callback",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: core.t.object({
-        provider: core.t.optional(core.t.string())
-      })
-    },
-    handler: async ({ url, cookies, query }) => {
-      const { client } = this.provider(query.provider);
-      const authorizationCode = this.authorizationCode.get(cookies);
-      if (!authorizationCode) {
-        throw new server.BadRequestError("Missing code verifier");
-      }
-      const tokens = await openidClient.authorizationCodeGrant(client, url, {
-        pkceCodeVerifier: authorizationCode.codeVerifier
-      });
-      this.authorizationCode.del(cookies);
-      this.tokens.set(cookies, {
-        ...tokens,
-        issued_at: Date.now()
-      });
-      const user = this.userFromAccessToken(tokens.access_token);
-      if (user) {
-        this.user.set(cookies, user);
-      }
-      return Response.redirect(authorizationCode.redirectUri ?? "/");
+class ServerHeadProvider {
+  renderHead(template, head) {
+    let result = template;
+    const htmlAttributes = head.htmlAttributes;
+    if (htmlAttributes) {
+      result = result.replace(
+        /<html([^>]*)>/i,
+        (_, existingAttrs) => `<html${this.mergeAttributes(existingAttrs, htmlAttributes)}>`
+      );
     }
-  });
-  /**
-   *
-   * @param accessToken
-   * @protected
-   */
-  userFromAccessToken(accessToken) {
-    try {
-      const parts = accessToken.split(".");
-      if (parts.length !== 3) {
-        return;
-      }
-      const payload = parts[1];
-      const decoded = JSON.parse(atob(payload));
-      if (!decoded.sub) {
-        return;
-      }
-      return {
-        id: decoded.sub,
-        name: decoded.name,
-        email: decoded.email
-        // organization
-        // ...
-      };
-    } catch (e) {
-      this.log.warn(e, "Failed to decode access token");
+    const bodyAttributes = head.bodyAttributes;
+    if (bodyAttributes) {
+      result = result.replace(
+        /<body([^>]*)>/i,
+        (_, existingAttrs) => `<body${this.mergeAttributes(existingAttrs, bodyAttributes)}>`
+      );
     }
-  }
-  /**
-   *
-   */
-  logout = server.$route({
-    security: false,
-    internal: true,
-    url: "/_oauth/logout",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: core.t.object({
-        redirect: core.t.optional(core.t.string()),
-        provider: core.t.optional(core.t.string())
-      })
-    },
-    handler: async ({ query, cookies }) => {
-      const { client } = this.provider(query.provider);
-      const tokens = this.tokens.get(cookies);
-      const idToken = tokens?.id_token;
-      const redirect = query.redirect ?? "/";
-      const params = new URLSearchParams();
-      params.set("post_logout_redirect_uri", redirect);
-      if (idToken) {
-        params.set("id_token_hint", idToken);
+    let headContent = "";
+    const title = head.title;
+    if (title) {
+      if (template.includes("<title>")) {
+        result = result.replace(
+          /<title>(.*?)<\/title>/i,
+          () => `<title>${this.escapeHtml(title)}</title>`
+        );
+      } else {
+        headContent += `<title>${this.escapeHtml(title)}</title>
+`;
       }
-      this.tokens.del(cookies);
-      this.user.del(cookies);
-      return Response.redirect(openidClient.buildEndSessionUrl(client, params).toString());
     }
-  });
-  /**
-   *
-   * @param name
-   * @protected
-   */
-  provider(name) {
-    if (!name) {
-      const client = this.authProviders[0];
-      if (!client) {
-        throw new server.BadRequestError("Client name is required");
+    if (head.meta) {
+      for (const meta of head.meta) {
+        headContent += `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">
+`;
       }
-      return client;
     }
-    const authProvider = this.authProviders.find(
-      (provider) => provider.name === name
+    result = result.replace(
+      /<head([^>]*)>(.*?)<\/head>/is,
+      (_, existingAttrs, existingHead) => `<head${existingAttrs}>${existingHead}${headContent}</head>`
     );
-    if (!authProvider) {
-      throw new server.BadRequestError(`Client ${name} not found`);
-    }
-    return authProvider;
+    return result.trim();
   }
-  /**
-   *
-   * @param file
-   * @protected
-   */
-  isViteFile(file) {
-    const [pathname] = file.split("?");
-    if (pathname.startsWith("/docs")) {
-      return false;
-    }
-    if (pathname.match(/\.\w{2,5}$/)) {
-      return true;
-    }
-    if (pathname.startsWith("/@")) {
-      return true;
+  mergeAttributes(existing, attrs) {
+    const existingAttrs = this.parseAttributes(existing);
+    const merged = { ...existingAttrs, ...attrs };
+    return Object.entries(merged).map(([k, v]) => ` ${k}="${this.escapeHtml(v)}"`).join("");
+  }
+  parseAttributes(attrStr) {
+    const attrs = {};
+    const attrRegex = /([^\s=]+)(?:="([^"]*)")?/g;
+    let match = attrRegex.exec(attrStr);
+    while (match) {
+      attrs[match[1]] = match[2] ?? "";
+      match = attrRegex.exec(attrStr);
     }
-    return false;
+    return attrs;
+  }
+  escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
   }
 }
 
-const envSchema$1 = core.t.object({
+const envSchema = 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);
-  env = core.$inject(envSchema$1);
+  pageDescriptorProvider = core.$inject(useActive.PageDescriptorProvider);
+  serverStaticProvider = core.$inject(serverStatic.ServerStaticProvider);
+  serverRouterProvider = core.$inject(server.ServerRouterProvider);
+  headProvider = core.$inject(ServerHeadProvider);
+  env = core.$inject(envSchema);
+  ROOT_DIV_REGEX = new RegExp(
+    `<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`,
+    "is"
+  );
   configure = core.$hook({
     name: "configure",
     handler: async () => {
-      await this.configureRoutes();
-    }
-  });
-  async configureRoutes() {
-    if (this.alepha.isTest()) {
-      this.processDescriptors();
-    }
-    if (this.router.empty()) {
-      return;
-    }
-    if (process.env.VITE_ALEPHA_DEV === "true") {
-      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}`);
-      const route2 = this.createHandler(
-        () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0).then((it) => it ? this.checkTemplate(it) : void 0)
-      );
-      await this.server.route(route2);
-      await this.server.route({
-        ...route2,
-        url: "*"
-      });
-      return;
-    }
-    let root = "";
-    if (!this.alepha.isServerless()) {
-      const maybe = [
-        node_path.join(process.cwd(), this.env.REACT_SERVER_DIST),
-        node_path.join(process.cwd(), "..", this.env.REACT_SERVER_DIST)
-      ];
-      for (const it of maybe) {
-        if (node_fs.existsSync(it)) {
-          root = it;
-          break;
+      const pages = this.alepha.getDescriptorValues(useActive.$page);
+      if (pages.length === 0) {
+        return;
+      }
+      for (const { key, instance, value } of pages) {
+        const name = value.options.name ?? key;
+        if (this.alepha.isTest()) {
+          instance[key].render = this.createRenderFunction(name);
         }
       }
-      if (!root) {
-        this.log.warn("Missing static files, SSR will be disabled");
+      if (this.alepha.isServerless() === "vite") {
+        await this.configureVite();
         return;
       }
-      await this.server.serve(this.createStaticHandler(root));
+      let root = "";
+      if (!this.alepha.isServerless()) {
+        root = this.getPublicDirectory();
+        if (!root) {
+          this.log.warn("Missing static files, SSR will be disabled");
+          return;
+        }
+        await this.configureStaticServer(root);
+      }
+      const template = this.alepha.state("ReactServerProvider.template") ?? await promises.readFile(node_path.join(root, "index.html"), "utf-8");
+      await this.registerPages(async () => template);
+      this.alepha.state("ReactServerProvider.ssr", true);
+    }
+  });
+  async registerPages(templateLoader) {
+    for (const page of this.pageDescriptorProvider.getPages()) {
+      this.log.debug(`+ ${page.match} -> ${page.name}`);
+      await this.serverRouterProvider.route({
+        method: "GET",
+        path: page.match,
+        handler: this.createHandler(page, templateLoader)
+      });
     }
-    const template = this.checkTemplate(
-      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({
-      ...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`
-        );
+  getPublicDirectory() {
+    const maybe = [
+      node_path.join(process.cwd(), this.env.REACT_SERVER_DIST),
+      node_path.join(process.cwd(), "..", this.env.REACT_SERVER_DIST)
+    ];
+    for (const it of maybe) {
+      if (node_fs.existsSync(it)) {
+        return it;
       }
-      return template.replace(
-        `<div id="root"></div>`,
-        `<div id="root">${this.env.REACT_SSR_OUTLET}</div>`
-      );
     }
-    return template;
+    return "";
   }
-  /**
-   *
-   * @param root
-   * @protected
-   */
-  createStaticHandler(root) {
-    return {
+  async configureStaticServer(root) {
+    await this.serverStaticProvider.serve({
       root,
-      prefix: this.env.REACT_SERVER_PREFIX,
-      logLevel: "warn",
-      cacheControl: true,
-      immutable: true,
-      preCompressed: true,
-      maxAge: "30d",
-      index: false
-    };
+      path: this.env.REACT_SERVER_PREFIX
+    });
   }
-  /**
-   *
-   * @param templateLoader
-   * @protected
-   */
-  createHandler(templateLoader) {
-    return {
-      method: "GET",
-      url: "/",
-      handler: async (ctx) => {
-        const template = await templateLoader();
-        if (!template) {
-          return new Response("Not found", { status: 404 });
-        }
-        const response = this.notFoundHandler(ctx.url);
-        if (response) {
-          return response;
-        }
-        return await this.ssr(ctx.url, template, ctx);
-      }
+  async configureVite() {
+    const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
+    this.log.info("SSR (vite) OK");
+    this.alepha.state("ReactServerProvider.ssr", true);
+    const templateUrl = `${url}/index.html`;
+    await this.registerPages(
+      () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0)
+    );
+  }
+  createRenderFunction(name) {
+    return async (options = {}) => {
+      const page = this.pageDescriptorProvider.page(name);
+      const state = await this.pageDescriptorProvider.createLayers(page, {
+        url: new URL("http://localhost"),
+        params: options.params ?? {},
+        query: options.query ?? {},
+        head: {}
+      });
+      return server$1.renderToString(this.pageDescriptorProvider.root(state));
     };
   }
-  processDescriptors() {
-    const pages = this.alepha.getDescriptorValues(useAuth.$page);
-    for (const { key, instance, value } of pages) {
-      instance[key].render = async (options = {}) => {
-        const name = value.options.name ?? key;
-        const page = this.router.page(name);
-        const layers = await this.router.createLayers(
-          "",
-          page,
-          options.params ?? {},
-          options.query ?? {},
-          []
-        );
-        return server$1.renderToString(
-          this.router.root({
-            layers,
-            pathname: "",
-            search: "",
-            context: {}
-          })
-        );
+  createHandler(page, templateLoader) {
+    return async (serverRequest) => {
+      const { url, reply, query, params } = serverRequest;
+      const template = await templateLoader();
+      if (!template) {
+        throw new Error("Template not found");
+      }
+      const request = {
+        url,
+        params,
+        query,
+        head: {}
       };
-    }
-  }
-  /**
-   *
-   * @param url
-   * @protected
-   */
-  notFoundHandler(url) {
-    if (url.pathname.match(/\.\w+$/)) {
-      return new Response("Not found", { status: 404 });
-    }
-  }
-  /**
-   *
-   * @param url
-   * @param template
-   * @param args
-   */
-  async ssr(url, template = this.env.REACT_SSR_OUTLET, args = {}) {
-    const { element, layers, redirect, context } = await this.router.render(
-      url.pathname + url.search,
-      {
-        args
+      if (this.alepha.has(server.ServerLinksProvider)) {
+        const srv = this.alepha.get(server.ServerLinksProvider);
+        request.links = await srv.links();
+        this.alepha.als.set("links", request.links);
       }
-    );
-    if (redirect) {
-      return new Response("", {
-        status: 302,
-        headers: {
-          Location: redirect
+      await this.alepha.run(
+        "react:server:render",
+        {
+          request: serverRequest,
+          pageRequest: request
+        },
+        {
+          log: false
         }
-      });
-    }
-    const appHtml = server$1.renderToString(element);
-    const script = `<script>window.__ssr=${JSON.stringify({
-      layers: layers.map((it) => ({
-        ...it,
-        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);
-    }
-    if (context.helmet) {
-      template = this.renderHelmetContext(template, context.helmet);
-    }
-    template = template.replace(this.env.REACT_SSR_OUTLET, appHtml);
-    return new Response(template, {
-      headers: { "Content-Type": "text/html" }
-    });
+      );
+      const state = await this.pageDescriptorProvider.createLayers(
+        page,
+        request
+      );
+      if (state.redirect) {
+        return reply.redirect(state.redirect);
+      }
+      const element = this.pageDescriptorProvider.root(state, request);
+      const app = server$1.renderToString(element);
+      const script = `<script>window.__ssr=${JSON.stringify({
+        links: request.links,
+        layers: state.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 response = {
+        html: template
+      };
+      reply.status = 200;
+      reply.headers["content-type"] = "text/html";
+      reply.headers["cache-control"] = "no-store, no-cache, must-revalidate, proxy-revalidate";
+      reply.headers.pragma = "no-cache";
+      reply.headers.expires = "0";
+      this.fillTemplate(response, app, script);
+      if (state.head) {
+        response.html = this.headProvider.renderHead(response.html, state.head);
+      }
+      return response.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>`
-        );
+  fillTemplate(response, app, script) {
+    if (this.ROOT_DIV_REGEX.test(response.html)) {
+      response.html = response.html.replace(
+        this.ROOT_DIV_REGEX,
+        (_match, beforeId, afterId) => {
+          return `<div${beforeId} id="${this.env.REACT_ROOT_ID}"${afterId}>${app}</div>`;
+        }
+      );
+    } else {
+      const bodyOpenTag = /<body([^>]*)>/i;
+      if (bodyOpenTag.test(response.html)) {
+        response.html = response.html.replace(bodyOpenTag, (match) => {
+          return `${match}
+<div id="${this.env.REACT_ROOT_ID}">${app}</div>`;
+        });
       }
     }
-    return template;
+    const bodyCloseTagRegex = /<\/body>/i;
+    if (bodyCloseTagRegex.test(response.html)) {
+      response.html = response.html.replace(
+        bodyCloseTagRegex,
+        `${script}
+</body>`
+      );
+    }
   }
 }
 
-const envSchema = core.t.object({
-  REACT_AUTH_ENABLED: core.t.boolean({ default: false })
-});
 class ReactModule {
-  env = core.$inject(envSchema);
   alepha = core.$inject(core.Alepha);
   constructor() {
-    this.alepha.with(server.ServerModule).with(server.ServerLinksProvider).with(useAuth.PageDescriptorProvider).with(ReactServerProvider);
-    if (this.env.REACT_AUTH_ENABLED) {
-      this.alepha.with(ReactAuthProvider);
-      this.alepha.with(useAuth.Auth);
-    }
+    this.alepha.with(server.ServerModule).with(server.ServerLinksProvider).with(useActive.PageDescriptorProvider).with(ReactServerProvider);
   }
 }
-core.autoInject(useAuth.$page, ReactModule);
-core.autoInject(useAuth.$auth, ReactAuthProvider, useAuth.Auth);
+core.__bind(useActive.$page, ReactModule);
 
-exports.$auth = useAuth.$auth;
-exports.$page = useAuth.$page;
-exports.Auth = useAuth.Auth;
-exports.Link = useAuth.Link;
-exports.NestedView = useAuth.NestedView;
-exports.PageDescriptorProvider = useAuth.PageDescriptorProvider;
-exports.ReactBrowserProvider = useAuth.ReactBrowserProvider;
-exports.RedirectionError = useAuth.RedirectionError;
-exports.Router = useAuth.Router;
-exports.RouterContext = useAuth.RouterContext;
-exports.RouterHookApi = useAuth.RouterHookApi;
-exports.RouterLayerContext = useAuth.RouterLayerContext;
-exports.pageDescriptorKey = useAuth.pageDescriptorKey;
-exports.useActive = useAuth.useActive;
-exports.useAuth = useAuth.useAuth;
-exports.useClient = useAuth.useClient;
-exports.useInject = useAuth.useInject;
-exports.useQueryParams = useAuth.useQueryParams;
-exports.useRouter = useAuth.useRouter;
-exports.useRouterEvents = useAuth.useRouterEvents;
-exports.useRouterState = useAuth.useRouterState;
-exports.ReactAuthProvider = ReactAuthProvider;
+exports.$page = useActive.$page;
+exports.Link = useActive.Link;
+exports.NestedView = useActive.NestedView;
+exports.PageDescriptorProvider = useActive.PageDescriptorProvider;
+exports.ReactBrowserProvider = useActive.ReactBrowserProvider;
+exports.RedirectionError = useActive.RedirectionError;
+exports.RouterContext = useActive.RouterContext;
+exports.RouterHookApi = useActive.RouterHookApi;
+exports.RouterLayerContext = useActive.RouterLayerContext;
+exports.isPageRoute = useActive.isPageRoute;
+exports.useActive = useActive.useActive;
+exports.useClient = useActive.useClient;
+exports.useInject = useActive.useInject;
+exports.useQueryParams = useActive.useQueryParams;
+exports.useRouter = useActive.useRouter;
+exports.useRouterEvents = useActive.useRouterEvents;
+exports.useRouterState = useActive.useRouterState;
 exports.ReactModule = ReactModule;
 exports.ReactServerProvider = ReactServerProvider;
-exports.envSchema = envSchema$1;
+exports.envSchema = envSchema;