ensure SectionBuilder can see Headers added via an @:include directive

typelevel · Dec 31, 2024 · e879bea · e879bea
1 parent 8778fc8
commit e879bea
Show file tree

Hide file tree

Showing 2 changed files with 12 additions and 9 deletions.
diff --git a/core/shared/src/main/scala/laika/internal/nav/SectionBuilder.scala b/core/shared/src/main/scala/laika/internal/nav/SectionBuilder.scala
@@ -63,21 +63,26 @@ private[laika] object SectionBuilder extends RewriteRulesBuilder {
 
     def buildSections(document: RootElement): RootElement = {
 
+      val flattenedDocument = document.content.flatMap {
+        case seq: BlockSequence if seq.options.styles.isEmpty => seq.content
+        case b: Block                                         => Seq(b)
+      }
+
       val docPosition = if (autonumberConfig.documents) position else TreePosition.root
 
       val (titleSection, rest) =
-        if (!extractTitle) (Nil, document.content)
+        if (!extractTitle) (Nil, flattenedDocument)
         else {
 
-          val title = document.content.collectFirst { case h: Header =>
+          val title = flattenedDocument.collectFirst { case h: Header =>
             if (autonumberConfig.documents)
               Title(addNumber(h.content, docPosition), h.options + Style.title)
             else Title(h.content, h.options + Style.title)
           }
 
-          title.fold((document.content, Seq.empty[Block])) { titleBlock =>
+          title.fold((flattenedDocument, Seq.empty[Block])) { titleBlock =>
             val (preface, rest) =
-              document.content.splitAt(document.content.indexWhere(_.isInstanceOf[Header]))
+              flattenedDocument.splitAt(flattenedDocument.indexWhere(_.isInstanceOf[Header]))
             (preface :+ titleBlock, rest.tail)
           }
         }

diff --git a/core/shared/src/main/scala/laika/internal/rewrite/RecursiveResolverRules.scala b/core/shared/src/main/scala/laika/internal/rewrite/RecursiveResolverRules.scala
@@ -32,27 +32,25 @@ private[laika] object RecursiveResolverRules {
       phase: RewritePhase
   ): RewriteRules = {
 
-    val removeScopes = phase.isInstanceOf[RewritePhase.Render]
-
     def rulesForScope(scope: ElementScope[_]): RewriteRules =
       applyTo(cursor.withReferenceContext(scope.context), baseRules, phase)
 
     lazy val rules: RewriteRules = RewriteRules.forBlocks {
       case ph: BlockResolver if ph.runsIn(phase) => Replace(rules.rewriteBlock(ph.resolve(cursor)))
-      case scope: BlockScope if removeScopes     =>
+      case scope: BlockScope     =>
         Replace(rulesForScope(scope).rewriteBlock(scope.content))
       case scope: BlockScope                     =>
         Replace(scope.copy(content = rulesForScope(scope).rewriteBlock(scope.content)))
     } ++ RewriteRules.forSpans {
       case ph: SpanResolver if ph.runsIn(phase) => Replace(rules.rewriteSpan(ph.resolve(cursor)))
-      case scope: SpanScope if removeScopes     =>
+      case scope: SpanScope     =>
         Replace(rulesForScope(scope).rewriteSpan(scope.content))
       case scope: SpanScope                     =>
         Replace(scope.copy(content = rulesForScope(scope).rewriteSpan(scope.content)))
     } ++ RewriteRules.forTemplates {
       case ph: SpanResolver if ph.runsIn(phase) =>
         Replace(rules.rewriteTemplateSpan(asTemplateSpan(ph.resolve(cursor))))
-      case scope: TemplateScope if removeScopes =>
+      case scope: TemplateScope =>
         Replace(rulesForScope(scope).rewriteTemplateSpan(scope.content))
       case scope: TemplateScope                 =>
         Replace(scope.copy(content = rulesForScope(scope).rewriteTemplateSpan(scope.content)))