render method

Future<void> render({ required GeneratorContext context, required List<ResolvedRoute> routes, })

Renders the provided routes into the project's GoRouter configuration.

Uses routing configuration from the generator context to update the appropriate router file.

Implementation

Future<void> render({
  required GeneratorContext context,
  required List<ResolvedRoute> routes,
}) async {
  final router = context.template.router;

  final routeFile = File(router.routeFile);
  final routerFile = File(router.routerFile);

  if (!routeFile.existsSync()) {
    throw Exception('Route file not found: ${routeFile.path}');
  }
  if (!routerFile.existsSync()) {
    throw Exception('Router file not found: ${routerFile.path}');
  }

  final routeContent = await routeFile.readAsString();
  final routerContent = await routerFile.readAsString();

  final statuses = const ExistingRouteResolver().resolve(
    discoveredRoutes: routes,
    routeContent: routeContent,
    routerContent: routerContent,
    routerFile: router.routerFile,
  );

  if (statuses.isEmpty) {
    LoggerService.info('Routes already synchronized.');
    return;
  }
  LoggerService.info('Synchronizing ${statuses.length} route(s).');

  var updatedRouteContent = routeContent;
  var updatedRouterContent = routerContent;

  for (final status in statuses) {
    final route = status.route;
    LoggerService.info('  • ${route.name}');

    if (status.requiresDefinition) {
      updatedRouteContent = _appendRouteDefinition(content: updatedRouteContent, route: route);
    }
    if (status.requiresImport) {
      updatedRouterContent = _appendImport(
        content: updatedRouterContent,
        route: route,
        routerFile: router.routerFile,
      );
    }
    if (status.requiresRegistration) {
      updatedRouterContent = _appendRouterRegistration(content: updatedRouterContent, route: route);
    }
  }

  if (updatedRouteContent != routeContent) {
    await writeFile(file: routeFile, content: updatedRouteContent, overwrite: true);
  }
  if (updatedRouterContent != routerContent) {
    await writeFile(file: routerFile, content: updatedRouterContent, overwrite: true);
  }
}