metanorma-document 0.2.8 → 0.2.12

data/lib/metanorma/html/itu_renderer.rb

@@ -2,52 +2,8 @@
 
 module Metanorma
   module Html
-    # ITU brand: #0e99d5 blue from logo
     class ItuRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["ITU"]
-      end
-
-      def flavor_publisher_name
-        "ITU"
-      end
-
-      def publisher_logo_map
-        { "ITU" => "itu-logo.svg" }
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.primary        = "#0a7bac"
-          t.accent         = "#0e99d5"
-          t.accent_deep    = "#0a7bac"
-          t.gradient       = "linear-gradient(135deg, #065a83 0%, #0a7bac 50%, #0e99d5 100%)"
-          t.primary_light  = "#e8f4fa"
-          t.accent_light   = "#daedf8"
-          t.warm           = "#b8860b"
-          t.warm_light     = "#fdf5e6"
-          t.sidebar_bg     = "#f2f6fa"
-          t.font_body      = '"Noto Serif", "Georgia", serif'
-          t.font_sans      = '"Noto Sans", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"Noto Sans Mono", "Menlo", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Noto+Sans:wght@400;500;600;700&family=Noto+Serif:ital,wght@0,400;0,500;0,600;1,400&family=Noto+Sans+Mono:wght@400;500&display=swap"
-          t.header_background = "linear-gradient(135deg, #065a83 0%, #0a7bac 40%, #0e99d5 100%)"
-          t.cover_background  = "linear-gradient(175deg, #043d5c 0%, #065a83 25%, #0a7bac 55%, #0e99d5 85%, #47b5e3 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 30% 15%, rgba(14,153,213,0.2) 0%, transparent 50%), radial-gradient(ellipse at 70% 80%, rgba(184,134,11,0.1) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #0e99d5, #b8860b, transparent)"
-          t.progress_bar_color = "#0e99d5"
-          t.note_border     = "#0e99d5"
-          t.note_bg         = "#daedf8"
-          t.note_color      = "#0e99d5"
-          t.example_border  = "#0a7bac"
-          t.example_bg      = "#e8f4fa"
-          t.example_color   = "#0a7bac"
-          t.admonition_border = "#b8860b"
-          t.admonition_color  = "#b8860b"
-          t.footer_border_color = "#0e99d5"
-          t.cover_separator_color = "rgba(14,153,213,0.25)"
-        end
-      end
+      register_render Metanorma::ItuDocument::Root, :render_document
     end
   end
 end

data/lib/metanorma/html/ogc_renderer.rb

@@ -2,83 +2,22 @@
 
 module Metanorma
   module Html
-    # Renders OgcDocument components to HTML.
-    # Extends IsoRenderer with OGC-specific branding (geospatial, OGC cyan-blue #00b1ff).
     class OgcRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["OGC"]
-      end
-
-      def flavor_publisher_name
-        "OGC"
-      end
-
-      def publisher_logo_map
-        { "OGC" => "ogc-logo.svg" }
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.primary        = "#0077b3"
-          t.accent         = "#00b1ff"
-          t.gradient       = "linear-gradient(135deg, #003d5c 0%, #0077b3 50%, #00b1ff 100%)"
-          t.accent_deep    = "#006699"
-          t.primary_light  = "#e8f4fa"
-          t.accent_light   = "#e0f4ff"
-          t.warm           = "#e8812e"
-          t.warm_light     = "#fff5eb"
-          t.sidebar_bg     = "#f2f8fc"
-          t.font_body      = '"Space Grotesk", "Helvetica Neue", Arial, sans-serif'
-          t.font_sans      = '"Space Grotesk", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"JetBrains Mono", "Fira Code", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-          t.header_background = "linear-gradient(135deg, #003d5c 0%, #0077b3 40%, #00b1ff 100%)"
-          t.cover_background  = "linear-gradient(175deg, #001f30 0%, #003d5c 25%, #0077b3 55%, #00b1ff 85%, #66d9ff 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 15%, rgba(0,177,255,0.2) 0%, transparent 45%), radial-gradient(ellipse at 75% 85%, rgba(0,119,179,0.25) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 4px; background: linear-gradient(90deg, transparent, #00b1ff 30%, #0077b3 50%, #00b1ff 70%, transparent)"
-          t.progress_bar_color = "#00b1ff"
-          t.note_border     = "#00b1ff"
-          t.note_bg         = "#e0f4ff"
-          t.note_color      = "#0077b3"
-          t.example_border  = "#0077b3"
-          t.example_bg      = "#e8f4fa"
-          t.example_color   = "#004d73"
-          t.admonition_border = "#e8812e"
-          t.admonition_bg = "#fff5eb"
-          t.admonition_color = "#c06a1a"
-          t.footer_border_color = "#00b1ff"
-          t.cover_separator_color = "rgba(0,177,255,0.25)"
-          t.dark_primary_light = "#0a2538"
-          t.dark_accent_light  = "#0d2030"
-          t.extra_css = <<~CSS
-            .sourcecode pre { background: #0a1a28; border-color: #1a3050; }
-            .reading-progress { box-shadow: 0 0 10px rgba(0,177,255,0.3); }
-            mark.search-match { background: #e0f4ff; box-shadow: 0 0 0 1px rgba(0,177,255,0.3); }
-            mark.search-match.search-current { background: #00b1ff; color: #fff; }
-            [data-theme="dark"] .sourcecode pre { background: #060e18; border-color: #0d2030; }
-          CSS
-        end
-      end
-
-      # OGC preface: wrap all preface clauses (except ToC) under a "Preface" heading.
-      # OGC documents have no foreword/introduction — their preface clauses are
-      # security, submitting_orgs, submission contacts, etc.
-      def render_preface(preface, **_opts)
-        preface_clauses = preface.clause&.reject { |cl| cl.type == "toc" } || []
-
-        return if preface_clauses.empty? &&
-          !preface.foreword && !preface.introduction &&
-          !preface.abstract && !preface.acknowledgements &&
-          !preface.executivesummary
-
-        @output << "<div id=\"preface\" class=\"preface-section\">"
-        register_toc_entry(id: "preface", level: 1, text: "Preface")
-        @output << "<h1 class=\"foreword-title\">Preface</h1>"
-
-        preface_clauses.each { |cl| render(cl, level: 2) }
-
-        @output << "</div>"
-      end
+      register_render Metanorma::OgcDocument::Root, :render_document
+      register_render Metanorma::StandardDocument::Sections::Preface,
+                      :render_preface
+      register_render Metanorma::StandardDocument::Sections::ClauseSection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::AnnexSection,
+                      :render_annex
+      register_render Metanorma::StandardDocument::Sections::ContentSection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::TermsSection,
+                      :render_terms_section
+      register_render Metanorma::StandardDocument::Sections::BibliographySection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::DefinitionSection,
+                      :render_clause
     end
   end
 end

data/lib/metanorma/html/oiml_renderer.rb

@@ -2,50 +2,30 @@
 
 module Metanorma
   module Html
-    # Renders OimlDocument (OIML) components to HTML.
-    # Extends IsoRenderer with OIML branding.
     class OimlRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["OIML"]
-      end
+      register_render Metanorma::OimlDocument::Root, :render_document
+
+      DOCTYPE_ID_PATTERN = /\b([RGBDEVS])\s*\d/
 
-      def flavor_publisher_name
-        "OIML"
+      def extract_doctype(bibdata)
+        oiml_doctype_from_doc_id(bibdata) || super
       end
 
-      def publisher_logo_map
-        {}
+      def extract_stage(bibdata)
+        oiml_doctype_from_doc_id(bibdata) || super
       end
 
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.font_body      = '"Merriweather", "Georgia", serif'
-          t.font_sans      = '"Montserrat", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"JetBrains Mono", "Fira Code", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Merriweather:ital,wght@0,300;0,400;0,700;1,400&family=Montserrat:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-          t.primary        = "#1a5c3a"
-          t.accent         = "#2e8b57"
-          t.accent_deep    = "#247049"
-          t.gradient       = "linear-gradient(135deg, #0d3d22 0%, #1a5c3a 50%, #2e8b57 100%)"
-          t.primary_light  = "#edf7f1"
-          t.accent_light   = "#e0f5e8"
-          t.warm           = "#d4a017"
-          t.warm_light     = "#fdf6e8"
-          t.header_background = "linear-gradient(135deg, #0d3d22 0%, #1a5c3a 50%, #2e8b57 100%)"
-          t.cover_background  = "linear-gradient(175deg, #071f14 0%, #0d3d22 30%, #1a5c3a 65%, #2e8b57 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 30% 20%, rgba(46,139,87,0.2) 0%, transparent 50%), radial-gradient(ellipse at 70% 80%, rgba(212,160,23,0.15) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #d4a017, transparent)"
-          t.progress_bar_color = "#2e8b57"
-          t.note_border     = "#2e8b57"
-          t.note_bg         = "#e0f5e8"
-          t.note_color      = "#2e8b57"
-          t.example_border  = "#1a5c3a"
-          t.example_bg      = "#edf7f1"
-          t.example_color   = "#1a5c3a"
-          t.admonition_border = "#d4a017"
-          t.admonition_color  = "#d4a017"
-          t.footer_border_color = "#2e8b57"
-          t.cover_separator_color = "rgba(46,139,87,0.25)"
+      private
+
+      def oiml_doctype_from_doc_id(bibdata)
+        labels = theme.doctype_labels
+        return nil if labels.empty?
+
+        doc_id = formatted_doc_id(bibdata).to_s
+        return nil if doc_id.empty?
+
+        if (match = doc_id.match(DOCTYPE_ID_PATTERN))
+          labels[match[1]]
         end
       end
     end

data/lib/metanorma/html/pdfa_renderer.rb

@@ -5,45 +5,6 @@ module Metanorma
     # Renders PDF Association (PDFA) taste documents to HTML.
     # PDFA brand: #cf9c1d gold + #d03544 red + #4992b2 steel blue from logo
     class PdfaRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["PDF Association"]
-      end
-
-      def flavor_publisher_name
-        "PDF Association"
-      end
-
-      def publisher_logo_map
-        { "PDF Association" => "pdfa-logo.svg" }
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.primary        = "#3a6e85"
-          t.accent         = "#cf9c1d"
-          t.accent_deep    = "#b08518"
-          t.gradient       = "linear-gradient(135deg, #2a5268 0%, #3a6e85 50%, #4992b2 100%)"
-          t.primary_light  = "#eef5f8"
-          t.accent_light   = "#fdf6e6"
-          t.warm           = "#d03544"
-          t.warm_light     = "#fdeef0"
-          t.header_background = "linear-gradient(135deg, #2a5268 0%, #3a6e85 40%, #4992b2 100%)"
-          t.cover_background  = "linear-gradient(175deg, #1a3848 0%, #2a5268 25%, #3a6e85 55%, #4992b2 85%, #cf9c1d 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 20%, rgba(207,156,29,0.15) 0%, transparent 50%), radial-gradient(ellipse at 70% 80%, rgba(73,146,178,0.2) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #cf9c1d, #d03544, transparent)"
-          t.progress_bar_color = "#cf9c1d"
-          t.note_border     = "#4992b2"
-          t.note_bg         = "#eef5f8"
-          t.note_color      = "#4992b2"
-          t.example_border  = "#3a6e85"
-          t.example_bg      = "#eef5f8"
-          t.example_color   = "#3a6e85"
-          t.admonition_border = "#d03544"
-          t.admonition_color  = "#d03544"
-          t.footer_border_color = "#cf9c1d"
-          t.cover_separator_color = "rgba(207,156,29,0.25)"
-        end
-      end
     end
   end
 end

data/lib/metanorma/html/renderers/block_renderer.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Metanorma
+  module Html
+    module Renderers
+      class BlockRenderer
+        BLOCK_CHILDREN = {
+          paragraphs: :render_paragraph,
+          ul: :render_unordered_list,
+          ol: :render_ordered_list,
+          dl: :render_definition_list,
+          sourcecode: :render_sourcecode,
+          table: :render_table,
+          figure: :render_figure,
+          quote: :render_quote,
+          formula: :render_formula,
+        }.freeze
+
+        SIMPLE_CHILDREN = {
+          paragraphs: :render_paragraph,
+        }.freeze
+
+        NOTE_CHILDREN = {
+          paragraphs: :render_paragraph,
+          ul: :render_unordered_list,
+          ol: :render_ordered_list,
+          dl: :render_definition_list,
+          quote: :render_quote,
+        }.freeze
+
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def render_paragraph(p, **_opts)
+          attrs = element_attrs(id: safe_attr(p, :id),
+                                style: coordinator.alignment_style(safe_attr(p,
+                                                                             :alignment)))
+          content = coordinator.render_mixed_inline(p)
+          render_liquid("_paragraph.html.liquid", {
+                          "attrs" => attrs,
+                          "content" => content,
+                        })
+        end
+
+        def render_table(table, **_opts)
+          attrs = element_attrs(id: safe_attr(table, :id), class: "table-block")
+          table_id = safe_attr(table, :id)
+          name_el = safe_attr(table, :fmt_name) || safe_attr(table, :name)
+          if table_id && name_el
+            register_table_entry(id: table_id,
+                                 text: coordinator.extract_plain_text(name_el))
+          end
+          col_count = table_column_count(table)
+
+          caption_html = if name_el
+                           coordinator.render_inline_element(name_el)
+                         end
+
+          colgroup_html = if table.colgroup
+                            render_table_colgroup(table.colgroup)
+                          end
+
+          thead_html = if table.thead
+                         render_table_section(table.thead, "thead")
+                       end
+
+          tbody_html = if table.tbody
+                         render_table_section(table.tbody, "tbody")
+                       end
+
+          tfoot_html = nil
+          if table.tfoot || (table.note && !table.note.empty?)
+            tfoot_inner = render_table_section_rows(table.tfoot) if table.tfoot
+            notes_html = nil
+            if table.note && !table.note.empty?
+              notes_inner = table.note.filter_map { |n| render_note(n) }.join
+              notes_html = render_liquid("_element.html.liquid", "tag" => "tr", "extra_attrs" => "",
+                                                                 "content" => render_liquid("_element.html.liquid", "tag" => "td", "extra_attrs" => %( colspan="#{col_count}" class="table-notes"), "content" => notes_inner))
+            end
+            tfoot_html = render_liquid("_element.html.liquid", "tag" => "tfoot", "extra_attrs" => "",
+                                                               "content" => "#{tfoot_inner}#{notes_html}")
+          end
+
+          render_liquid("_table.html.liquid", {
+                          "attrs" => attrs,
+                          "caption" => caption_html,
+                          "colgroup_html" => colgroup_html,
+                          "thead_html" => thead_html,
+                          "tbody_html" => tbody_html,
+                          "tfoot_html" => tfoot_html,
+                        })
+        end
+
+        def table_column_count(table)
+          if table.colgroup&.col && !table.colgroup.col.empty?
+            return table.colgroup.col.size
+          end
+
+          max_cols = 0
+          %i[thead tbody tfoot].each do |section|
+            sec = table.public_send(section)
+            next unless sec&.tr
+
+            sec.tr.each do |tr|
+              cols = 0
+              Array(tr.th).each do |th|
+                cols += th.colspan && th.colspan > 1 ? th.colspan : 1
+              end
+              Array(tr.td).each do |td|
+                cols += td.colspan && td.colspan > 1 ? td.colspan : 1
+              end
+              max_cols = cols if cols > max_cols
+            end
+          end
+          max_cols.positive? ? max_cols : 1
+        end
+
+        def render_table_colgroup(colgroup)
+          colgroup.col&.filter_map do |col|
+            attrs = element_attrs(style: col.width ? "width: #{col.width}" : nil)
+            render_liquid("_element.html.liquid", "tag" => "col",
+                                                  "extra_attrs" => attrs, "content" => "")
+          end&.join
+        end
+
+        def render_table_section(section, tag_name)
+          inner = render_table_section_rows(section)
+          render_liquid("_element.html.liquid", "tag" => tag_name,
+                                                "extra_attrs" => "", "content" => inner)
+        end
+
+        def render_table_section_rows(section)
+          section.tr&.filter_map do |tr|
+            inner_parts = []
+            walked = coordinator.walk_ordered(tr) do |type, obj|
+              next unless type == :element
+
+              inner_parts << (render_table_cell(obj) || "")
+            end
+            unless walked
+              Array(tr.th).each do |th|
+                inner_parts << (render_table_cell(th, "th") || "")
+              end
+              Array(tr.td).each do |td|
+                inner_parts << (render_table_cell(td, "td") || "")
+              end
+            end
+            render_liquid("_element.html.liquid", "tag" => "tr",
+                                                  "extra_attrs" => "", "content" => inner_parts.join)
+          end&.join
+        end
+
+        def render_unordered_list(ul, **_opts)
+          attrs = element_attrs(id: safe_attr(ul, :id))
+          items = ul.listitem&.filter_map do |li|
+            render_list_item_content(li)
+          end || []
+          render_liquid("_list.html.liquid", {
+                          "list_tag" => "ul",
+                          "attrs" => attrs,
+                          "items" => items,
+                        })
+        end
+
+        def render_table_cell(cell, force_tag = nil)
+          tag_name = force_tag || (cell.is_a?(Metanorma::Document::Components::Tables::HeaderTableCell) ? "th" : "td")
+          attrs = element_attrs(
+            colspan: safe_attr(cell, :colspan),
+            rowspan: safe_attr(cell, :rowspan),
+            align: safe_attr(cell, :alignment),
+            valign: safe_attr(cell, :vertical_alignment),
+          )
+          content = coordinator.render_cell_content(cell)
+          render_liquid("_element.html.liquid", {
+                          "tag" => tag_name,
+                          "extra_attrs" => attrs,
+                          "content" => content,
+                        })
+        end
+
+        def render_ordered_list(ol, **_opts)
+          attrs = element_attrs(id: safe_attr(ol, :id),
+                                start: safe_attr(ol, :start), type: safe_attr(ol, :type_attr))
+          items = ol.listitem&.filter_map do |li|
+            render_list_item_content(li)
+          end || []
+          render_liquid("_list.html.liquid", {
+                          "list_tag" => "ol",
+                          "attrs" => attrs,
+                          "items" => items,
+                        })
+        end
+
+        def render_list_item_content(li)
+          li_id = safe_attr(li, :id)
+          attrs = li_id ? %( id="#{escape_html(li_id)}") : ""
+          inner = coordinator.render_mixed_content_in_order(li)
+          render_liquid("_list_item.html.liquid", "attrs" => attrs,
+                                                  "content" => inner)
+        end
+
+        def render_definition_list(dl, **_opts)
+          attrs = element_attrs(id: safe_attr(dl, :id))
+          terms = dl.dt&.each_with_index&.map do |dt, i|
+            dt_html = coordinator.render_mixed_inline(dt)
+            dd = dl.dd&.[](i)
+            dd_html = dd ? coordinator.render_mixed_inline(dd) : nil
+            { "dt" => dt_html, "dd" => dd_html }
+          end || []
+          render_liquid("_definition_list.html.liquid", {
+                          "attrs" => attrs,
+                          "terms" => terms,
+                        })
+        end
+
+        def render_figure(figure, **_opts)
+          drop = Drops::FigureDrop.from_model(figure,
+                                              renderer: coordinator.renderer_context)
+          render_liquid("_figure.html.liquid", { "block" => drop })
+        end
+
+        def render_image(image)
+          src_val = image_source(image)
+          attrs = element_attrs(
+            id: safe_attr(image, :id),
+            src: src_val,
+            alt: safe_attr(image, :alt),
+            height: safe_attr(image, :height),
+            width: safe_attr(image, :width),
+          )
+          render_liquid("_image.html.liquid", { "attrs" => attrs })
+        end
+
+        def image_source(image)
+          svg_xml = safe_attr(image, :inline_svg)
+          if svg_xml && !svg_xml.empty?
+            "data:image/svg+xml;base64,#{Base64.strict_encode64(svg_xml)}"
+          else
+            safe_attr(image, :source)
+          end
+        end
+
+        def render_video(video)
+          attrs = element_attrs(
+            id: safe_attr(video, :id),
+            src: safe_attr(video, :src),
+          )
+          render_liquid("_video.html.liquid", { "attrs" => attrs })
+        end
+
+        def render_audio(audio)
+          attrs = element_attrs(
+            id: safe_attr(audio, :id),
+            src: safe_attr(audio, :src),
+          )
+          render_liquid("_audio.html.liquid", { "attrs" => attrs })
+        end
+
+        def render_note(note, **_opts)
+          drop = Drops::NoteDrop.from_model(note,
+                                            renderer: coordinator.renderer_context)
+          render_liquid("_note.html.liquid", { "block" => drop })
+        end
+
+        def render_example(example, **_opts)
+          drop = Drops::ExampleDrop.from_model(example,
+                                               renderer: coordinator.renderer_context)
+          render_liquid("_example.html.liquid", { "block" => drop })
+        end
+
+        def render_sourcecode(sc, **_opts)
+          drop = Drops::SourcecodeDrop.from_model(sc,
+                                                  renderer: coordinator.renderer_context)
+          render_liquid("_sourcecode.html.liquid", { "block" => drop })
+        end
+
+        def render_formula(formula, **_opts)
+          drop = Drops::FormulaDrop.from_model(formula,
+                                               renderer: coordinator.renderer_context)
+          render_liquid("_formula.html.liquid", { "block" => drop })
+        end
+
+        def render_quote(quote, **_opts)
+          attrs = element_attrs(id: safe_attr(quote, :id), class: "quote")
+          content_parts = []
+          quote.paragraphs&.each do |para|
+            content_parts << (render_paragraph(para) || "")
+          end
+          quote.ul&.each do |ul|
+            content_parts << (render_unordered_list(ul) || "")
+          end
+          quote.ol&.each do |ol|
+            content_parts << (render_ordered_list(ol) || "")
+          end
+          content = content_parts.join
+          attribution_html = if quote.attribution
+                               coordinator.render_mixed_inline(quote.attribution)
+                             end
+          render_liquid("_quote.html.liquid", {
+                          "attrs" => attrs,
+                          "content" => content,
+                          "attribution" => attribution_html,
+                        })
+        end
+
+        def render_admonition(admonition, **_opts)
+          drop = Drops::AdmonitionDrop.from_model(admonition,
+                                                  renderer: coordinator.renderer_context)
+          render_liquid("_admonition.html.liquid", { "block" => drop })
+        end
+
+        def render_bookmark(bookmark, **_opts)
+          render_liquid("_bookmark.html.liquid", {
+                          "id" => escape_html(safe_attr(bookmark, :id).to_s),
+                        })
+        end
+
+        def render_block_children(model, children:)
+          parts = []
+          children.each do |attr, render_method|
+            values = safe_attr(model, attr)
+            next if values.nil?
+
+            Array(values).each do |v|
+              parts << (public_send(render_method, v) || "")
+            end
+          end
+          parts.join
+        end
+
+        def render_note_children(model)
+          render_block_children(model, children: NOTE_CHILDREN)
+        end
+
+        def render_simple_children(model)
+          render_block_children(model, children: SIMPLE_CHILDREN)
+        end
+
+        def render_full_block_children(model)
+          render_block_children(model, children: BLOCK_CHILDREN)
+        end
+
+        private
+
+        attr_reader :coordinator
+
+        def safe_attr(obj, method_name)
+          coordinator.safe_attr(obj, method_name)
+        end
+
+        def escape_html(text)
+          coordinator.escape_html(text)
+        end
+
+        def element_attrs(**attrs)
+          coordinator.element_attrs(**attrs)
+        end
+
+        def render_liquid(template_name, assigns)
+          coordinator.render_liquid(template_name, assigns)
+        end
+
+        def register_table_entry(id:, text:)
+          coordinator.register_table_entry(id: id, text: text)
+        end
+      end
+    end
+  end
+end