@vaadin/hilla-file-router 24.8.6 → 24.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/hilla-file-router",
-  "version": "24.8.6",
+  "version": "24.8.7",
   "description": "Hilla file-based router",
   "main": "index.js",
   "module": "index.js",
@@ -62,9 +62,9 @@
   },
   "dependencies": {
     "@ungap/with-resolvers": "0.1.0",
-    "@vaadin/hilla-generator-utils": "24.8.6",
-    "@vaadin/hilla-react-auth": "24.8.6",
-    "@vaadin/hilla-react-signals": "24.8.6",
+    "@vaadin/hilla-generator-utils": "24.8.7",
+    "@vaadin/hilla-react-auth": "24.8.7",
+    "@vaadin/hilla-react-signals": "24.8.7",
     "tsc-template": "0.2.3",
     "typescript": "5.8.3"
   }

package/runtime/configuration-builder/RouterConfigurationBuilder.d.ts

@@ -0,0 +1,129 @@
+import type { ComponentType } from "react";
+import { type RouteObject } from "react-router";
+import type { AgnosticRoute, RouterBuildOptions, RouterConfiguration, ViewConfig } from "../../types.js";
+import type { RouteLike, RouteTransformer } from "./utils.js";
+/**
+* A configuration builder for creating a Vaadin-specific router for React with
+* authentication and server routes support.
+*
+* The configuration builder allows you to compose and modify route trees by
+* chaining methods that add custom React routes, generated file-based routes,
+* layout components, etc. Modifiers are accumulated and applied in order when
+* building the final router configuration.
+*
+* @example
+* ```typescript
+* const { routes, router } = new RouteConfigurationBuilder()
+*   .withFileRoutes(fileRoutes)
+*   .withReactRoutes({ path: '/foo/baz', element: <FooBazPage /> })
+*   .withFallback(Flow)
+*   .protect('/login')
+*   .build();
+* ```
+*/
+export declare class RouterConfigurationBuilder {
+	#private;
+	/**
+	* Adds the given React routes to the current list of routes. All the routes
+	* are deeply merged to preserve the path uniqueness.
+	*
+	* @param routes - An array of React Router route objects to be merged into
+	* the current route list.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withReactRoutes(routes: readonly RouteObject[]): this;
+	/**
+	* Adds the given file routes to the current list of routes. All the routes
+	* are transformed to React RouterObjects and deeply merged to preserve the
+	* path uniqueness.
+	*
+	* @param routes - An array of file-based route objects to be processed and
+	* merged into the current route list.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withFileRoutes(routes: readonly AgnosticRoute[]): this;
+	/**
+	* Adds a fallback component for each branch of the current route tree.
+	*
+	* The fallback component is used when no other route matches the requested
+	* URL. In terms of Vaadin application, after no match on the client side, the
+	* turn goes to the server-side router.
+	*
+	* @remarks This method can be called only once. All the subsequent calls will
+	* be ignored.
+	*
+	* @remarks This method also runs the `withLayout` method with the given
+	* component to make sure server-side layout is applied to routes.
+	*
+	* @param component - The component to use as the fallback and layout
+	* component.
+	* @param config - Optional view configuration for the fallback component.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withFallback(component: ComponentType, config?: ViewConfig): this;
+	/**
+	* Adds the parent layout to all views with the `flowLayouts` flag set in the
+	* ViewConfiguration.
+	*
+	* @remarks This method can be called only once. All the subsequent calls will
+	* be ignored.
+	*
+	* @param component - The component to use as the layout for the routes.
+	* Usually, it is `Flow` component.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withLayout(component: ComponentType): this;
+	/**
+	* Adds protection to the route, requiring authentication or authorization to
+	* access it.
+	*
+	* @param redirectPath - Optional path to redirect to when protection fails.
+	* If not provided, the default redirect page (`/login`) will be used.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	protect(redirectPath?: string): this;
+	/**
+	* Deeply updates the current route tree, merging the existing routes with the
+	* given routes using the provided transformer callback.
+	*
+	* @param routes - The routes used to update the current route tree.
+	* @param callback - A transformer function that defines how the routes should
+	* be modified. Required if `routes` are not provided.
+	*
+	* @returns This RouteConfigurationBuilder instance for method chaining
+	*/
+	update(routes: undefined, callback: RouteTransformer): this;
+	/**
+	* Deeply updates the current route tree, merging the existing routes with the
+	* given routes using the provided transformer callback.
+	*
+	* @typeParam T - The type of routes being updated.
+	*
+	* @param routes - The routes used to update the current route tree.
+	* @param callback - A transformer function that defines how the routes should
+	* be modified. Required if `routes` are not provided.
+	*
+	* @returns This RouteConfigurationBuilder instance for method chaining
+	*/
+	update<T extends RouteLike>(routes: readonly T[], callback?: RouteTransformer<T>): this;
+	/**
+	* Builds the router configuration by applying all registered modifiers to the
+	* routes.
+	*
+	* @remarks
+	* This method applies the the logic for layout skipping along with any other
+	* registered modifiers to transform the routes.
+	*
+	* @param options - Optional React `createBrowserRouter` options to configure
+	* the router.
+	*
+	* @returns A RouterConfiguration object containing the processed routes and
+	* configured browser router
+	*/
+	build(options?: RouterBuildOptions): RouterConfiguration;
+}

package/runtime/configuration-builder/RouterConfigurationBuilder.js

@@ -0,0 +1,153 @@
+import { createBrowserRouter } from "react-router";
+import createFallbackTransformer, { createFallbackRoutes } from "./createFallbackTransformer.js";
+import createProtectTransformer from "./createProtectTransformer.js";
+import fileRouteTransformer from "./fileRouteTransformer.js";
+import mergeLayout from "./mergeLayout.js";
+import { mergeRouteTrees } from "./mergeRouteTrees.js";
+import mergeSkipLayouts from "./mergeSkipLayout.js";
+/**
+* A configuration builder for creating a Vaadin-specific router for React with
+* authentication and server routes support.
+*
+* The configuration builder allows you to compose and modify route trees by
+* chaining methods that add custom React routes, generated file-based routes,
+* layout components, etc. Modifiers are accumulated and applied in order when
+* building the final router configuration.
+*
+* @example
+* ```typescript
+* const { routes, router } = new RouteConfigurationBuilder()
+*   .withFileRoutes(fileRoutes)
+*   .withReactRoutes({ path: '/foo/baz', element: <FooBazPage /> })
+*   .withFallback(Flow)
+*   .protect('/login')
+*   .build();
+* ```
+*/
+export class RouterConfigurationBuilder {
+	#modifiers = [];
+	#isFallbackSet = false;
+	#isLayoutSet = false;
+	/**
+	* Adds the given React routes to the current list of routes. All the routes
+	* are deeply merged to preserve the path uniqueness.
+	*
+	* @param routes - An array of React Router route objects to be merged into
+	* the current route list.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withReactRoutes(routes) {
+		this.update(routes);
+		return this;
+	}
+	/**
+	* Adds the given file routes to the current list of routes. All the routes
+	* are transformed to React RouterObjects and deeply merged to preserve the
+	* path uniqueness.
+	*
+	* @param routes - An array of file-based route objects to be processed and
+	* merged into the current route list.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withFileRoutes(routes) {
+		this.update(routes, fileRouteTransformer);
+		return this;
+	}
+	/**
+	* Adds a fallback component for each branch of the current route tree.
+	*
+	* The fallback component is used when no other route matches the requested
+	* URL. In terms of Vaadin application, after no match on the client side, the
+	* turn goes to the server-side router.
+	*
+	* @remarks This method can be called only once. All the subsequent calls will
+	* be ignored.
+	*
+	* @remarks This method also runs the `withLayout` method with the given
+	* component to make sure server-side layout is applied to routes.
+	*
+	* @param component - The component to use as the fallback and layout
+	* component.
+	* @param config - Optional view configuration for the fallback component.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withFallback(component, config) {
+		if (!this.#isFallbackSet) {
+			this.#isFallbackSet = true;
+			this.withLayout(component);
+			const fallbackRoutes = createFallbackRoutes(component, config);
+			this.update(
+				// Add the fallback routes to the end of the route tree.
+				fallbackRoutes,
+				// Add the fallback routes to each route tree branch via transformer.
+				createFallbackTransformer(fallbackRoutes)
+);
+		}
+		return this;
+	}
+	/**
+	* Adds the parent layout to all views with the `flowLayouts` flag set in the
+	* ViewConfiguration.
+	*
+	* @remarks This method can be called only once. All the subsequent calls will
+	* be ignored.
+	*
+	* @param component - The component to use as the layout for the routes.
+	* Usually, it is `Flow` component.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	withLayout(component) {
+		if (!this.#isLayoutSet) {
+			this.#isLayoutSet = true;
+			this.#modifiers.push((originalRoutes) => mergeLayout(originalRoutes, component));
+		}
+		return this;
+	}
+	/**
+	* Adds protection to the route, requiring authentication or authorization to
+	* access it.
+	*
+	* @param redirectPath - Optional path to redirect to when protection fails.
+	* If not provided, the default redirect page (`/login`) will be used.
+	*
+	* @returns The current instance of the builder for method chaining.
+	*/
+	protect(redirectPath) {
+		this.update(undefined, createProtectTransformer(redirectPath));
+		return this;
+	}
+	update(routes, callback) {
+		this.#modifiers.push((originalRoutes) => mergeRouteTrees(originalRoutes, routes, callback));
+		return this;
+	}
+	/**
+	* Builds the router configuration by applying all registered modifiers to the
+	* routes.
+	*
+	* @remarks
+	* This method applies the the logic for layout skipping along with any other
+	* registered modifiers to transform the routes.
+	*
+	* @param options - Optional React `createBrowserRouter` options to configure
+	* the router.
+	*
+	* @returns A RouterConfiguration object containing the processed routes and
+	* configured browser router
+	*/
+	build(options) {
+		this.#modifiers.push((originalRoutes) => mergeSkipLayouts(originalRoutes));
+		const routes = this.#modifiers.reduce((acc, mod) => mod(acc) ?? acc, undefined) ?? [];
+		return {
+			routes,
+			router: createBrowserRouter([...routes], {
+				basename: new URL(document.baseURI).pathname,
+				...options
+			})
+		};
+	}
+}
+//# sourceMappingURL=./RouterConfigurationBuilder.js.map

package/runtime/configuration-builder/RouterConfigurationBuilder.js.map

@@ -0,0 +1 @@
+{"mappings":"AAEA,SAAS,yCAA4D;AAErE,OAAO,6BAA6B,4DAA6D;AACjG,OAAO,6DAA8D;AACrE,OAAO,qDAAsD;AAC7D,OAAO,mCAAoC;AAC3C,SAAS,6CAA8C;AACvD,OAAO,4CAA6C;;;;;;;;;;;;;;;;;;;;AAsBpD,OAAO,MAAM,2BAA2B;CACtC,AAASA,aAAkC,CAAE;CAC7C,iBAAiB;CACjB,eAAe;;;;;;;;;;CAWf,gBAAgBC,QAAsC;AACpD,OAAK,OAAO,OAAO;AACnB,SAAO;CACR;;;;;;;;;;;CAYD,eAAeC,QAAwC;AACrD,OAAK,OAAO,QAAQ,qBAAqB;AACzC,SAAO;CACR;;;;;;;;;;;;;;;;;;;;CAqBD,aAAaC,WAA0BC,QAA2B;AAChE,OAAK,KAAKC,gBAAgB;AACxB,QAAKA,iBAAiB;AACtB,QAAK,WAAW,UAAU;GAE1B,MAAM,iBAAiB,qBAAqB,WAAW,OAAO;AAE9D,QAAK;;IAEH;;IAEA,0BAA0B,eAAe;CAC1C;EACF;AACD,SAAO;CACR;;;;;;;;;;;;;CAcD,WAAWF,WAAgC;AACzC,OAAK,KAAKG,cAAc;AACtB,QAAKA,eAAe;AACpB,QAAKN,WAAW,KAAK,CAAC,mBAAmB,YAAY,gBAAgB,UAAU,CAAC;EACjF;AACD,SAAO;CACR;;;;;;;;;;CAWD,QAAQO,cAA6B;AACnC,OAAK,OAAO,WAAW,yBAAyB,aAAa,CAAC;AAC9D,SAAO;CACR;CA2BD,OAA4BC,QAAkCC,UAAqC;AACjG,OAAKT,WAAW,KAAK,CAAC,mBAAmB,gBAAgB,gBAAgB,QAAQ,SAAS,CAAC;AAC3F,SAAO;CACR;;;;;;;;;;;;;;;CAgBD,MAAMU,SAAmD;AACvD,OAAKV,WAAW,KAAK,CAAC,mBAAmB,iBAAiB,eAAe,CAAC;EAC1E,MAAM,SACJ,KAAKA,WAAW,OAA2C,CAAC,KAAK,QAAQ,IAAI,IAAI,IAAI,KAAK,UAAU,IAAI,CAAE;AAE5G,SAAO;GACL;GACA,QAAQ,oBAAoB,CAAC,GAAG,MAAO,GAAE;IAAE,UAAU,IAAI,IAAI,SAAS,SAAS;IAAU,GAAG;GAAS,EAAC;EACvG;CACF;AACF","names":["#modifiers","routes: readonly RouteObject[]","routes: readonly AgnosticRoute[]","component: ComponentType","config?: ViewConfig","#isFallbackSet","#isLayoutSet","redirectPath?: string","routes: readonly T[] | undefined","callback: RouteTransformer<T>","options?: RouterBuildOptions"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/file-router/src/runtime/configuration-builder/RouterConfigurationBuilder.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-use-before-define */\nimport type { ComponentType } from 'react';\nimport { createBrowserRouter, type RouteObject } from 'react-router';\nimport type { AgnosticRoute, RouterBuildOptions, RouterConfiguration, ViewConfig } from '../../types.js';\nimport createFallbackTransformer, { createFallbackRoutes } from './createFallbackTransformer.js';\nimport createProtectTransformer from './createProtectTransformer.js';\nimport fileRouteTransformer from './fileRouteTransformer.js';\nimport mergeLayout from './mergeLayout.js';\nimport { mergeRouteTrees } from './mergeRouteTrees.js';\nimport mergeSkipLayouts from './mergeSkipLayout.js';\nimport type { RouteLike, RouteTreeModifier, RouteTransformer } from './utils.js';\n\n/**\n * A configuration builder for creating a Vaadin-specific router for React with\n * authentication and server routes support.\n *\n * The configuration builder allows you to compose and modify route trees by\n * chaining methods that add custom React routes, generated file-based routes,\n * layout components, etc. Modifiers are accumulated and applied in order when\n * building the final router configuration.\n *\n * @example\n * ```typescript\n * const { routes, router } = new RouteConfigurationBuilder()\n *   .withFileRoutes(fileRoutes)\n *   .withReactRoutes({ path: '/foo/baz', element: <FooBazPage /> })\n *   .withFallback(Flow)\n *   .protect('/login')\n *   .build();\n * ```\n */\nexport class RouterConfigurationBuilder {\n  readonly #modifiers: RouteTreeModifier[] = [];\n  #isFallbackSet = false;\n  #isLayoutSet = false;\n\n  /**\n   * Adds the given React routes to the current list of routes. All the routes\n   * are deeply merged to preserve the path uniqueness.\n   *\n   * @param routes - An array of React Router route objects to be merged into\n   * the current route list.\n   *\n   * @returns The current instance of the builder for method chaining.\n   */\n  withReactRoutes(routes: readonly RouteObject[]): this {\n    this.update(routes);\n    return this;\n  }\n\n  /**\n   * Adds the given file routes to the current list of routes. All the routes\n   * are transformed to React RouterObjects and deeply merged to preserve the\n   * path uniqueness.\n   *\n   * @param routes - An array of file-based route objects to be processed and\n   * merged into the current route list.\n   *\n   * @returns The current instance of the builder for method chaining.\n   */\n  withFileRoutes(routes: readonly AgnosticRoute[]): this {\n    this.update(routes, fileRouteTransformer);\n    return this;\n  }\n\n  /**\n   * Adds a fallback component for each branch of the current route tree.\n   *\n   * The fallback component is used when no other route matches the requested\n   * URL. In terms of Vaadin application, after no match on the client side, the\n   * turn goes to the server-side router.\n   *\n   * @remarks This method can be called only once. All the subsequent calls will\n   * be ignored.\n   *\n   * @remarks This method also runs the `withLayout` method with the given\n   * component to make sure server-side layout is applied to routes.\n   *\n   * @param component - The component to use as the fallback and layout\n   * component.\n   * @param config - Optional view configuration for the fallback component.\n   *\n   * @returns The current instance of the builder for method chaining.\n   */\n  withFallback(component: ComponentType, config?: ViewConfig): this {\n    if (!this.#isFallbackSet) {\n      this.#isFallbackSet = true;\n      this.withLayout(component);\n\n      const fallbackRoutes = createFallbackRoutes(component, config);\n\n      this.update(\n        // Add the fallback routes to the end of the route tree.\n        fallbackRoutes,\n        // Add the fallback routes to each route tree branch via transformer.\n        createFallbackTransformer(fallbackRoutes),\n      );\n    }\n    return this;\n  }\n\n  /**\n   * Adds the parent layout to all views with the `flowLayouts` flag set in the\n   * ViewConfiguration.\n   *\n   * @remarks This method can be called only once. All the subsequent calls will\n   * be ignored.\n   *\n   * @param component - The component to use as the layout for the routes.\n   * Usually, it is `Flow` component.\n   *\n   * @returns The current instance of the builder for method chaining.\n   */\n  withLayout(component: ComponentType): this {\n    if (!this.#isLayoutSet) {\n      this.#isLayoutSet = true;\n      this.#modifiers.push((originalRoutes) => mergeLayout(originalRoutes, component));\n    }\n    return this;\n  }\n\n  /**\n   * Adds protection to the route, requiring authentication or authorization to\n   * access it.\n   *\n   * @param redirectPath - Optional path to redirect to when protection fails.\n   * If not provided, the default redirect page (`/login`) will be used.\n   *\n   * @returns The current instance of the builder for method chaining.\n   */\n  protect(redirectPath?: string): this {\n    this.update(undefined, createProtectTransformer(redirectPath));\n    return this;\n  }\n\n  /**\n   * Deeply updates the current route tree, merging the existing routes with the\n   * given routes using the provided transformer callback.\n   *\n   * @param routes - The routes used to update the current route tree.\n   * @param callback - A transformer function that defines how the routes should\n   * be modified. Required if `routes` are not provided.\n   *\n   * @returns This RouteConfigurationBuilder instance for method chaining\n   */\n  update(routes: undefined, callback: RouteTransformer): this;\n\n  /**\n   * Deeply updates the current route tree, merging the existing routes with the\n   * given routes using the provided transformer callback.\n   *\n   * @typeParam T - The type of routes being updated.\n   *\n   * @param routes - The routes used to update the current route tree.\n   * @param callback - A transformer function that defines how the routes should\n   * be modified. Required if `routes` are not provided.\n   *\n   * @returns This RouteConfigurationBuilder instance for method chaining\n   */\n  update<T extends RouteLike>(routes: readonly T[], callback?: RouteTransformer<T>): this;\n  update<T extends RouteLike>(routes: readonly T[] | undefined, callback: RouteTransformer<T>): this {\n    this.#modifiers.push((originalRoutes) => mergeRouteTrees(originalRoutes, routes, callback));\n    return this;\n  }\n\n  /**\n   * Builds the router configuration by applying all registered modifiers to the\n   * routes.\n   *\n   * @remarks\n   * This method applies the the logic for layout skipping along with any other\n   * registered modifiers to transform the routes.\n   *\n   * @param options - Optional React `createBrowserRouter` options to configure\n   * the router.\n   *\n   * @returns A RouterConfiguration object containing the processed routes and\n   * configured browser router\n   */\n  build(options?: RouterBuildOptions): RouterConfiguration {\n    this.#modifiers.push((originalRoutes) => mergeSkipLayouts(originalRoutes));\n    const routes =\n      this.#modifiers.reduce<readonly RouteObject[] | undefined>((acc, mod) => mod(acc) ?? acc, undefined) ?? [];\n\n    return {\n      routes,\n      router: createBrowserRouter([...routes], { basename: new URL(document.baseURI).pathname, ...options }),\n    };\n  }\n}\n"],"version":3}

package/runtime/configuration-builder/createFallbackTransformer.d.ts

@@ -0,0 +1,44 @@
+import { type ComponentType } from "react";
+import type { RouteObject } from "react-router";
+import type { ViewConfig } from "../../types.js";
+import { type RouteTransformer } from "./utils.js";
+/**
+* A tuple of fallback routes:
+* - A wildcard route (`path: '*'`) that renders the component for any unmatched
+* path.
+* - An index route (`index: true`) that renders the component for the empty
+* path.
+*/
+export type FallbackRoutes = readonly [notFoundFallback: RouteObject, indexFallback: RouteObject];
+/**
+* Creates fallback routes for handling unmatched paths and index routes.
+*
+* @param component - The React component to render for the fallback routes
+* @param config - Optional view configuration to attach to the route handles
+*
+* @returns A tuple of fallback routes.
+*/
+export declare function createFallbackRoutes(component: ComponentType, config?: ViewConfig): FallbackRoutes;
+/**
+* Creates a route transformer that adds fallback routes to handle unmatched
+* paths.
+*
+* This transformer adds two types of fallback routes:
+* - A wildcard route (`path: '*'`) that renders the specified fallback
+* component for any unmatched path.
+* - An index fallback route (`index: true`) that renders the fallback component
+* for the empty path.
+*
+* The transformer logic determines which fallback to add based on the existing
+* child routes:
+* - If a wildcard child route already defined, only the index fallback is
+* added.
+* - If an index or optional child route exists, only the wildcard fallback is
+* added.
+* - Otherwise, both fallback routes are added.
+*
+* @param component - The React component to render as the fallback.
+* @param config - A view configuration of the fallback route if any.
+* @returns A route transformer function.
+*/
+export default function createFallbackTransformer([notFoundFallback, indexFallback]: FallbackRoutes): RouteTransformer;

package/runtime/configuration-builder/createFallbackTransformer.js

@@ -0,0 +1,90 @@
+import { createElement } from "react";
+import { getHandleFlag, RouteHandleFlag } from "./utils.js";
+/**
+* Creates fallback routes for handling unmatched paths and index routes.
+*
+* @param component - The React component to render for the fallback routes
+* @param config - Optional view configuration to attach to the route handles
+*
+* @returns A tuple of fallback routes.
+*/
+export function createFallbackRoutes(component, config) {
+	return [{
+		path: "*",
+		element: createElement(component),
+		handle: config
+	}, {
+		index: true,
+		element: createElement(component),
+		handle: config
+	}];
+}
+/**
+* Determines whether the given route object represents an index route.
+*
+* @param route - The route object to check.
+*/
+function isIndexRoute(route) {
+	return !!route.index;
+}
+/**
+* Determines whether the given route is optional based on its path.
+*
+* @param route - The route object to check.
+*/
+function isOptionalRoute(route) {
+	return !!route.path?.includes("?");
+}
+/**
+* Determines whether the given route is a wildcard route.
+*
+* @param route - The route object to check.
+*/
+function isWildcardRoute(route) {
+	return route.path === "*";
+}
+/**
+* Creates a route transformer that adds fallback routes to handle unmatched
+* paths.
+*
+* This transformer adds two types of fallback routes:
+* - A wildcard route (`path: '*'`) that renders the specified fallback
+* component for any unmatched path.
+* - An index fallback route (`index: true`) that renders the fallback component
+* for the empty path.
+*
+* The transformer logic determines which fallback to add based on the existing
+* child routes:
+* - If a wildcard child route already defined, only the index fallback is
+* added.
+* - If an index or optional child route exists, only the wildcard fallback is
+* added.
+* - Otherwise, both fallback routes are added.
+*
+* @param component - The React component to render as the fallback.
+* @param config - A view configuration of the fallback route if any.
+* @returns A route transformer function.
+*/
+export default function createFallbackTransformer([notFoundFallback, indexFallback]) {
+	return ({ original, override, children, dupe }) => {
+		if (original && !getHandleFlag(original, RouteHandleFlag.IGNORE_FALLBACK) && !dupe) {
+			if (!children) {
+				return original;
+			}
+			let fallback;
+			if (children.some((route) => isWildcardRoute(route))) {
+				fallback = [indexFallback];
+			} else if (children.some((route) => isIndexRoute(route) || isOptionalRoute(route))) {
+				fallback = [notFoundFallback];
+			} else {
+				fallback = [notFoundFallback, indexFallback];
+			}
+			return {
+				...original,
+				children: [...children, ...fallback]
+			};
+		}
+		return override;
+	};
+}
+//# sourceMappingURL=./createFallbackTransformer.js.map

package/runtime/configuration-builder/createFallbackTransformer.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAA6B,4BAA6B;AAG1D,SAAS,eAAe,mCAA2D;;;;;;;;;AAmBnF,OAAO,SAAS,qBAAqBA,WAA0BC,QAAqC;AAClG,QAAO,CACL;EAAE,MAAM;EAAK,SAAS,cAAc,UAAU;EAAE,QAAQ;CAAQ,GAChE;EAAE,OAAO;EAAM,SAAS,cAAc,UAAU;EAAE,QAAQ;CAAQ,CACnE;AACF;;;;;;AAOD,SAAS,aAAaC,OAA6B;AACjD,UAAS,MAAM;AAChB;;;;;;AAOD,SAAS,gBAAgBA,OAA6B;AACpD,UAAS,MAAM,MAAM,SAAS,IAAI;AACnC;;;;;;AAOD,SAAS,gBAAgBA,OAA6B;AACpD,QAAO,MAAM,SAAS;AACvB;;;;;;;;;;;;;;;;;;;;;;;AAwBD,eAAe,SAAS,0BAA0B,CAAC,kBAAkB,cAA8B,EAAoB;AACrH,QAAO,CAAC,EAAE,UAAU,UAAU,UAAU,MAAM,KAAK;AACjD,MAAI,aAAa,cAAc,UAAU,gBAAgB,gBAAgB,KAAK,MAAM;AAClF,QAAK,UAAU;AACb,WAAO;GACR;GAED,IAAIC;AAEJ,OAAI,SAAS,KAAK,CAAC,UAAU,gBAAgB,MAAM,CAAC,EAAE;AACpD,eAAW,CAAC,aAAc;GAC3B,WAAU,SAAS,KAAK,CAAC,UAAU,aAAa,MAAM,IAAI,gBAAgB,MAAM,CAAC,EAAE;AAClF,eAAW,CAAC,gBAAiB;GAC9B,OAAM;AACL,eAAW,CAAC,kBAAkB,aAAc;GAC7C;AAGD,UAAO;IACL,GAAG;IACH,UAAU,CAAC,GAAG,UAAU,GAAG,QAAS;GACrC;EACF;AAED,SAAO;CACR;AACF","names":["component: ComponentType","config?: ViewConfig","route: RouteObject","fallback: RouteObject[]"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/file-router/src/runtime/configuration-builder/createFallbackTransformer.ts"],"sourcesContent":["import { type ComponentType, createElement } from 'react';\nimport type { RouteObject, NonIndexRouteObject } from 'react-router';\nimport type { ViewConfig } from '../../types.js';\nimport { getHandleFlag, RouteHandleFlag, type RouteTransformer } from './utils.js';\n\n/**\n * A tuple of fallback routes:\n * - A wildcard route (`path: '*'`) that renders the component for any unmatched\n * path.\n * - An index route (`index: true`) that renders the component for the empty\n * path.\n */\nexport type FallbackRoutes = readonly [notFoundFallback: RouteObject, indexFallback: RouteObject];\n\n/**\n * Creates fallback routes for handling unmatched paths and index routes.\n *\n * @param component - The React component to render for the fallback routes\n * @param config - Optional view configuration to attach to the route handles\n *\n * @returns A tuple of fallback routes.\n */\nexport function createFallbackRoutes(component: ComponentType, config?: ViewConfig): FallbackRoutes {\n  return [\n    { path: '*', element: createElement(component), handle: config },\n    { index: true, element: createElement(component), handle: config },\n  ];\n}\n\n/**\n * Determines whether the given route object represents an index route.\n *\n * @param route - The route object to check.\n */\nfunction isIndexRoute(route: RouteObject): boolean {\n  return !!route.index;\n}\n\n/**\n * Determines whether the given route is optional based on its path.\n *\n * @param route - The route object to check.\n */\nfunction isOptionalRoute(route: RouteObject): boolean {\n  return !!route.path?.includes('?');\n}\n\n/**\n * Determines whether the given route is a wildcard route.\n *\n * @param route - The route object to check.\n */\nfunction isWildcardRoute(route: RouteObject): boolean {\n  return route.path === '*';\n}\n\n/**\n * Creates a route transformer that adds fallback routes to handle unmatched\n * paths.\n *\n * This transformer adds two types of fallback routes:\n * - A wildcard route (`path: '*'`) that renders the specified fallback\n * component for any unmatched path.\n * - An index fallback route (`index: true`) that renders the fallback component\n * for the empty path.\n *\n * The transformer logic determines which fallback to add based on the existing\n * child routes:\n * - If a wildcard child route already defined, only the index fallback is\n * added.\n * - If an index or optional child route exists, only the wildcard fallback is\n * added.\n * - Otherwise, both fallback routes are added.\n *\n * @param component - The React component to render as the fallback.\n * @param config - A view configuration of the fallback route if any.\n * @returns A route transformer function.\n */\nexport default function createFallbackTransformer([notFoundFallback, indexFallback]: FallbackRoutes): RouteTransformer {\n  return ({ original, override, children, dupe }) => {\n    if (original && !getHandleFlag(original, RouteHandleFlag.IGNORE_FALLBACK) && !dupe) {\n      if (!children) {\n        return original; //: IndexRouteObject;\n      }\n\n      let fallback: RouteObject[];\n\n      if (children.some((route) => isWildcardRoute(route))) {\n        fallback = [indexFallback];\n      } else if (children.some((route) => isIndexRoute(route) || isOptionalRoute(route))) {\n        fallback = [notFoundFallback];\n      } else {\n        fallback = [notFoundFallback, indexFallback];\n      }\n\n      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n      return {\n        ...original,\n        children: [...children, ...fallback],\n      } as NonIndexRouteObject;\n    }\n\n    return override as RouteObject | undefined;\n  };\n}\n"],"version":3}

package/runtime/configuration-builder/createProtectTransformer.d.ts

@@ -0,0 +1,11 @@
+import type { RouteTransformer } from "./utils.js";
+/**
+* Creates a route transformer that applies route protection to a given route,
+* optionally redirecting unauthorized access to a specified path.
+*
+* @param redirectPath - Optional path to redirect unauthorized users to.
+* Defaults to '/login'.
+*
+* @returns A route transformer function that applies protection to the route.
+*/
+export default function createProtectTransformer(redirectPath?: string): RouteTransformer;

package/runtime/configuration-builder/createProtectTransformer.js

@@ -0,0 +1,21 @@
+import { protectRoute } from "@vaadin/hilla-react-auth";
+/**
+* Creates a route transformer that applies route protection to a given route,
+* optionally redirecting unauthorized access to a specified path.
+*
+* @param redirectPath - Optional path to redirect unauthorized users to.
+* Defaults to '/login'.
+*
+* @returns A route transformer function that applies protection to the route.
+*/
+export default function createProtectTransformer(redirectPath) {
+	return ({ original, children }) => {
+		if (!original) {
+			return original;
+		}
+		const finalRoute = protectRoute(original, redirectPath);
+		finalRoute.children = children;
+		return finalRoute;
+	};
+}
+//# sourceMappingURL=./createProtectTransformer.js.map

package/runtime/configuration-builder/createProtectTransformer.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAAS,8CAA+C;;;;;;;;;;AAaxD,eAAe,SAAS,yBAAyBA,cAAyC;AACxF,QAAO,CAAC,EAAE,UAAU,UAAU,KAAK;AACjC,OAAK,UAAU;AACb,UAAO;EACR;EAED,MAAM,aAAa,aAAa,UAAU,aAAa;AACvD,aAAW,WAAW;AACtB,SAAO;CACR;AACF","names":["redirectPath?: string"],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/file-router/src/runtime/configuration-builder/createProtectTransformer.ts"],"sourcesContent":["import { protectRoute } from '@vaadin/hilla-react-auth';\nimport type { RouteObject } from 'react-router';\nimport type { RouteTransformer } from './utils.js';\n\n/**\n * Creates a route transformer that applies route protection to a given route,\n * optionally redirecting unauthorized access to a specified path.\n *\n * @param redirectPath - Optional path to redirect unauthorized users to.\n * Defaults to '/login'.\n *\n * @returns A route transformer function that applies protection to the route.\n */\nexport default function createProtectTransformer(redirectPath?: string): RouteTransformer {\n  return ({ original, children }) => {\n    if (!original) {\n      return original;\n    }\n\n    const finalRoute = protectRoute(original, redirectPath);\n    finalRoute.children = children as RouteObject[] | undefined;\n    return finalRoute;\n  };\n}\n"],"version":3}

package/runtime/configuration-builder/fileRouteTransformer.d.ts

@@ -0,0 +1,17 @@
+import type { RouteObject } from "react-router";
+import type { AgnosticRoute } from "../../types.js";
+import { type RouteTransformerOptions } from "./utils.js";
+/**
+* Transforms a framework-agnostic route into a route object compatible with
+* React Router and merges it with the existing route object if any.
+*
+* @param options - The route transformer options containing the existing route,
+* any overrides, and child routes.
+*
+* @returns A `RouteObject` representing the transformed route, or the original
+* route if no override is provided.
+*
+* @throws If the provided module does not export a React component by default
+* nor a ViewConfig object as "config".
+*/
+export default function fileRouteTransformer({ original, override, children }: RouteTransformerOptions<AgnosticRoute>): RouteObject | undefined;

package/runtime/configuration-builder/fileRouteTransformer.js

@@ -0,0 +1,47 @@
+import { createElement } from "react";
+import { convertComponentNameToTitle } from "../../shared/convertComponentNameToTitle.js";
+import { isReactRouteModule } from "./utils.js";
+/**
+* Transforms a framework-agnostic route into a route object compatible with
+* React Router and merges it with the existing route object if any.
+*
+* @param options - The route transformer options containing the existing route,
+* any overrides, and child routes.
+*
+* @returns A `RouteObject` representing the transformed route, or the original
+* route if no override is provided.
+*
+* @throws If the provided module does not export a React component by default
+* nor a ViewConfig object as "config".
+*/
+export default function fileRouteTransformer({ original, override, children }) {
+	if (!override) {
+		return original;
+	}
+	const { module, component = module?.default, config = module?.config, path, flowLayout } = override;
+	if (module && !isReactRouteModule(module)) {
+		throw new Error(`The module for the "${path}" section doesn't have the React component exported by default or a ViewConfig object exported as "config"`);
+	}
+	const element = component ? createElement(component) : undefined;
+	const handle = {
+		...config,
+		title: config?.title ?? convertComponentNameToTitle(component),
+		flowLayout: config?.flowLayout ?? flowLayout
+	};
+	if (path === "" && !children) {
+		return {
+			...original,
+			element,
+			handle,
+			index: true
+		};
+	}
+	return {
+		...original,
+		path: config?.route ?? path,
+		element,
+		children,
+		handle
+	};
+}
+//# sourceMappingURL=./fileRouteTransformer.js.map

package/runtime/configuration-builder/fileRouteTransformer.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAAS,4BAA6B;AAEtC,SAAS,gFAAiF;AAE1F,SAAS,sCAAqE;;;;;;;;;;;;;;AAe9E,eAAe,SAAS,qBAAqB,EAC3C,UACA,UACA,UACuC,EAA2B;AAClE,MAAK,UAAU;AACb,SAAO;CACR;CAED,MAAM,EAAE,QAAQ,YAAY,QAAQ,SAAS,SAAS,QAAQ,QAAQ,MAAM,YAAY,GAAG;AAE3F,KAAI,WAAW,mBAAmB,OAAO,EAAE;AACzC,QAAM,IAAI,OACP,sBAAsB,KAAK;CAE/B;CAED,MAAM,UAAU,YAAY,cAAc,UAAU,GAAG;CACvD,MAAM,SAAS;EACb,GAAG;EACH,OAAO,QAAQ,SAAS,4BAA4B,UAAU;EAC9D,YAAY,QAAQ,cAAc;CACnC;AAED,KAAI,SAAS,OAAO,UAAU;AAC5B,SAAO;GACL,GAAI;GACJ;GACA;GACA,OAAO;EACR;CACF;AAED,QAAO;EACL,GAAI;EACJ,MAAM,QAAQ,SAAS;EACvB;EACU;EACV;CACD;AACF","names":[],"sources":["/opt/agent/work/1af72d8adc613024/hilla/packages/ts/file-router/src/runtime/configuration-builder/fileRouteTransformer.ts"],"sourcesContent":["import { createElement } from 'react';\nimport type { IndexRouteObject, NonIndexRouteObject, RouteObject } from 'react-router';\nimport { convertComponentNameToTitle } from '../../shared/convertComponentNameToTitle.js';\nimport type { AgnosticRoute } from '../../types.js';\nimport { isReactRouteModule, type RouteTransformerOptions } from './utils.js';\n\n/**\n * Transforms a framework-agnostic route into a route object compatible with\n * React Router and merges it with the existing route object if any.\n *\n * @param options - The route transformer options containing the existing route,\n * any overrides, and child routes.\n *\n * @returns A `RouteObject` representing the transformed route, or the original\n * route if no override is provided.\n *\n * @throws If the provided module does not export a React component by default\n * nor a ViewConfig object as \"config\".\n */\nexport default function fileRouteTransformer({\n  original,\n  override,\n  children,\n}: RouteTransformerOptions<AgnosticRoute>): RouteObject | undefined {\n  if (!override) {\n    return original;\n  }\n\n  const { module, component = module?.default, config = module?.config, path, flowLayout } = override;\n\n  if (module && !isReactRouteModule(module)) {\n    throw new Error(\n      `The module for the \"${path}\" section doesn't have the React component exported by default or a ViewConfig object exported as \"config\"`,\n    );\n  }\n\n  const element = component ? createElement(component) : undefined;\n  const handle = {\n    ...config,\n    title: config?.title ?? convertComponentNameToTitle(component),\n    flowLayout: config?.flowLayout ?? flowLayout,\n  };\n\n  if (path === '' && !children) {\n    return {\n      ...(original as IndexRouteObject),\n      element,\n      handle,\n      index: true,\n    } satisfies IndexRouteObject;\n  }\n\n  return {\n    ...(original as NonIndexRouteObject),\n    path: config?.route ?? path,\n    element,\n    children: children as RouteObject[] | undefined,\n    handle,\n  } satisfies NonIndexRouteObject;\n}\n"],"version":3}

package/runtime/configuration-builder/mergeLayout.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentType } from "react";
+import type { RouteObject } from "react-router";
+/**
+* Splits out the server-side route tree based on the {@link ViewConfiguration.flowLayout}
+* flag, and wraps them in the provided server layout component.
+*
+* @remarks
+* Internally, routes are categorized into three groups:
+* - **Server routes**: Routes with `flowLayout` flag explicitly set to `true`,
+* or routes whose children have the flag enabled.
+* - **Client routes**: Routes with `flowLayout` flag explicitly set to `false`,
+* or routes with client-side children.
+* - **Unknown routes**: Routes without explicit flags that inherit behavior
+* from their parent context.
+*
+* Server routes get the {@link RouteHandleFlag.IGNORE_FALLBACK} flag set to
+* prevent fallback route interference. Client routes are preserved as-is.
+*
+* @param originalRoutes - The current route tree to process.
+* @param component - The layout component to wrap around server routes.
+*
+* @returns A new route configuration with the layout applied to server routes.
+*/
+export default function mergeLayout(originalRoutes: readonly RouteObject[] | undefined, component: ComponentType): readonly RouteObject[] | undefined;