generate method

Future<List<File>> generate(
  1. Iterable<StaticPage> pages, {
  2. required String outputDirectory,
})

Implementation

Future<List<File>> generate(
  Iterable<StaticPage> pages, {
  required String outputDirectory,
}) async {
  final siteBaseUrl = _siteBaseUrl;
  if (outputDirectory.isEmpty) {
    throw ArgumentError.value(
      outputDirectory,
      'outputDirectory',
      'An output directory is required.',
    );
  }

  if (_generateSeoFiles && siteBaseUrl == null) {
    throw ArgumentError(
      'A siteBaseUrl is required to generate sitemap.xml and robots.txt.',
    );
  }

  final preparedPages = <_PreparedStaticPage>[];
  final generatedPaths = <String>{};
  final sitemapUrls = <String>{};
  for (final page in pages) {
    final segments = _pathSegments(page.path);
    if (!generatedPaths.add(segments.join('/'))) {
      throw StateError('Duplicate static page path "${page.path}".');
    }
    if (_generateSeoFiles && _reservedSeoOutputPath(segments)) {
      throw ArgumentError.value(
        page.path,
        'path',
        'Static pages cannot use the reserved /sitemap.xml or /robots.txt path.',
      );
    }

    final sourceMetadata = page.metadata ?? HeadMetadata.defaults();
    final canonicalUrl = sourceMetadata.canonicalUrl ??
        (siteBaseUrl == null ? null : _canonicalUrl(segments, siteBaseUrl));
    final canonicalUri = canonicalUrl == null || siteBaseUrl == null
        ? null
        : _validateCanonicalUrl(canonicalUrl, page.path);
    final isIndexable =
        page.indexable && sourceMetadata.robots?.index != false;
    final robots = page.indexable
        ? sourceMetadata.robots
        : (sourceMetadata.robots ?? const RobotsDirectives())
            .copyWith(index: false);
    final metadata = HeadMetadata(
      title: sourceMetadata.title,
      description: sourceMetadata.description,
      canonicalUrl: canonicalUrl,
      metaTags: sourceMetadata.metaTags,
      jsonLd: sourceMetadata.jsonLd,
      openGraph: sourceMetadata.openGraph,
      twitterCard: sourceMetadata.twitterCard,
      robots: robots,
      language: sourceMetadata.language,
      locale: sourceMetadata.locale,
    );

    if (_generateSeoFiles &&
        isIndexable &&
        canonicalUri != null &&
        siteBaseUrl != null) {
      final sameOrigin = _hasSameOrigin(canonicalUri, siteBaseUrl);
      if (sameOrigin && !sitemapUrls.add(canonicalUri.toString())) {
        throw StateError(
          'Duplicate canonical URL "${canonicalUri.toString()}" in sitemap.',
        );
      }
    }

    preparedPages.add(
      _PreparedStaticPage(page, segments, metadata),
    );
  }

  final generatedFiles = <File>[];
  for (final prepared in preparedPages) {
    final page = prepared.page;
    var directoryPath = outputDirectory;
    for (final segment in prepared.segments) {
      directoryPath = '$directoryPath${Platform.pathSeparator}$segment';
    }

    final directory = Directory(directoryPath);
    await directory.create(recursive: true);
    final file = File(
      '$directoryPath${Platform.pathSeparator}index.html',
    );
    await file.writeAsString(
      _renderer.render(
        page.component,
        metadata: prepared.metadata,
        clientScript: _clientScript,
        documentStylesheets: _documentStylesheets,
      ),
    );
    generatedFiles.add(file);
  }

  if (_generateSeoFiles) {
    final output = Directory(outputDirectory);
    await output.create(recursive: true);
    final sortedSitemapUrls = sitemapUrls.toList()..sort();
    await File(
      '${output.path}${Platform.pathSeparator}sitemap.xml',
    ).writeAsString(_sitemapXml(sortedSitemapUrls));
    await File(
      '${output.path}${Platform.pathSeparator}robots.txt',
    ).writeAsString(_robotsTxt());
  }

  return List<File>.unmodifiable(generatedFiles);
}