pageflow 17.1.0 → 17.2.0

data/entry_types/scrolled/app/assets/stylesheets/pageflow_scrolled/ui.scss

@@ -0,0 +1,2 @@
+@import "pageflow/ui/properties";
+@import "pageflow/ui/overrides";

data/entry_types/scrolled/app/controllers/pageflow_scrolled/editor/content_elements_controller.rb

@@ -17,17 +17,26 @@ module PageflowScrolled
         section = Section.all_for_revision(@entry.draft).find(params[:section_id])
 
         items = params.require(:content_elements).map do |item|
-          item.transform_keys(&:underscore).permit(:id, :type_name, :_delete, configuration: {})
+          item.transform_keys(&:underscore).permit(:id, :type_name, :_delete,
+                                                   configuration: {},
+                                                   migrate_comment_threads: [])
         end
 
-        @content_elements = ContentElement::Batch.new(section, items).save!
+        @content_elements = ContentElement::Batch.new(
+          section, items,
+          comment_thread_subject_ranges: permitted_subject_ranges
+        ).save!
       rescue ActiveRecord::RecordNotFound
         head :not_found
       end
 
       def update
         content_element = ContentElement.all_for_revision(@entry.draft).find(params[:id])
-        content_element.update(content_element_params)
+
+        ContentElement.transaction do
+          content_element.update(content_element_params)
+          update_comment_thread_subject_ranges(content_element)
+        end
 
         head :no_content
       rescue ActiveRecord::RecordNotFound
@@ -66,6 +75,27 @@ module PageflowScrolled
               .permit(:type_name, :position)
               .merge(configuration:)
       end
+
+      def update_comment_thread_subject_ranges(content_element)
+        ranges = permitted_subject_ranges
+        return if ranges.blank?
+
+        Pageflow::CommentThread.update_subject_ranges_for(
+          revision: @entry.draft,
+          subject_type: 'ContentElement',
+          subject_id: content_element.perma_id,
+          ranges:
+        )
+      end
+
+      def permitted_subject_ranges
+        ranges = params[:comment_thread_subject_ranges]
+        return nil if ranges.blank?
+
+        ranges.to_unsafe_h.transform_values do |range|
+          range.is_a?(Hash) ? range.slice('anchor', 'focus') : {}
+        end
+      end
     end
   end
 end

data/entry_types/scrolled/app/controllers/pageflow_scrolled/editor/sections_controller.rb

@@ -41,11 +41,10 @@ module PageflowScrolled
 
       def order
         chapter = Chapter.all_for_revision(@entry.draft).find(params[:chapter_id])
-        storyline = chapter.storyline
 
         params.require(:ids).each_with_index do |id, index|
-          storyline.sections.find(id).update(chapter_id: chapter.id,
-                                             position: index)
+          Section.all_for_revision(@entry.draft).find(id).update(chapter_id: chapter.id,
+                                                                 position: index)
         end
 
         head :no_content

data/entry_types/scrolled/app/controllers/pageflow_scrolled/entries_controller.rb

@@ -15,15 +15,35 @@ module PageflowScrolled
 
     def show
       entry = get_published_entry_from_env
+      mode = get_entry_mode_from_env
 
       I18n.locale = entry.locale
 
       render(
         locals: {
           entry:,
-          widget_scope: get_entry_mode_from_env
+          entry_mode: mode,
+          seed_options: seed_options(entry, mode)
         }
       )
     end
+
+    private
+
+    def seed_options(entry, mode)
+      options = {
+        embed: get_embed_from_env,
+        origin_url: request.original_url
+      }
+
+      if mode == :preview
+        # Published entries are cached without taking the requesting
+        # user into account. Only previews may depend on their locale.
+        options[:ui_locale] = get_ui_locale_from_env
+        options[:load_commenting] = true if entry.feature_state('commenting')
+      end
+
+      options
+    end
   end
 end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/cache_helper.rb

@@ -1,11 +1,11 @@
 module PageflowScrolled
   # @api private
   module CacheHelper
-    def cache_scrolled_entry(entry:, widget_scope:, &)
+    def cache_scrolled_entry(entry:, entry_mode:, &)
       condition =
-        widget_scope == :published &&
+        entry_mode == :published &&
         entry.feature_state('scrolled_entry_fragment_caching')
-      cache_if(condition, [entry, :head_and_body, widget_scope], &)
+      cache_if(condition, [entry, :head_and_body, entry_mode], &)
     end
   end
 end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/editor/entry_json_seed_helper.rb

@@ -11,14 +11,16 @@ module PageflowScrolled
         entry_config = Pageflow.config_for(scrolled_entry)
 
         scrolled_entry_editor_legacy_typography_variants_seed(json, entry_config)
-        scrolled_entry_editor_consent_vendor_host_matchers_seed(json, entry_config)
+        scrolled_entry_editor_consent_vendor_url_matchers_seed(json, entry_config)
 
         scrolled_entry_json_seed(json,
                                  scrolled_entry,
                                  skip_files: true,
                                  skip_i18n: true,
                                  include_hidden_sections: true,
-                                 include_unused_additional_seed_data: true)
+                                 include_unused_additional_seed_data: true,
+                                 include_unused_file_reference_locations: true,
+                                 include_theme_translations: true)
       end
 
       private
@@ -31,10 +33,10 @@ module PageflowScrolled
         )
       end
 
-      def scrolled_entry_editor_consent_vendor_host_matchers_seed(json, entry_config)
-        json.consent_vendor_host_matchers(
+      def scrolled_entry_editor_consent_vendor_url_matchers_seed(json, entry_config)
+        json.consent_vendor_url_matchers(
           entry_config
-            .consent_vendor_host_matchers
+            .consent_vendor_url_matchers
             .transform_keys { |regexp| regexp.inspect[1..-2] }
         )
       end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/editor/seed_html_helper.rb

@@ -8,6 +8,7 @@ module PageflowScrolled
       include Pageflow::StructuredDataHelper
       include Pageflow::TextDirectionHelper
       include PageflowScrolled::CacheHelper
+      include PageflowScrolled::SprocketsHelper
       include FaviconHelper
       include PacksHelper
       include WebpackPublicPathHelper
@@ -16,7 +17,7 @@ module PageflowScrolled
         html = render(template: 'pageflow_scrolled/entries/show',
                       locals: {
                         entry:,
-                        widget_scope: :editor,
+                        entry_mode: :editor,
                         skip_ssr: true,
                         skip_structured_data: true,
                         skip_feed_link_tags: true,
@@ -24,7 +25,9 @@ module PageflowScrolled
                         seed_options: {
                           skip_collections: true,
                           include_unused_additional_seed_data: true,
-                          translations: {include_inline_editing: true}
+                          include_unused_file_reference_locations: true,
+                          include_theme_translations: true,
+                          load_inline_editing: true
                         }
                       })
 

data/entry_types/scrolled/app/helpers/pageflow_scrolled/entry_json_seed_helper.rb

@@ -18,22 +18,30 @@ module PageflowScrolled
         scrolled_entry_json_seed(json, scrolled_entry, options)
       end
 
-      content_tag(:script, <<-JS.html_safe)
-        pageflowScrolledRender(#{sanitize_json(seed_json)});
-      JS
+      content_tag(:script,
+                  sanitize_json(seed_json).html_safe,
+                  type: 'application/json',
+                  data: {pageflow_scrolled_seed: true})
     end
 
     def scrolled_entry_json_seed(json, scrolled_entry, options = {})
       revision = scrolled_entry.revision
       sections = scrolled_entry_json_seed_sections(scrolled_entry, options)
+      content_elements = scrolled_entry_json_seed_content_elements(revision, sections)
+      entry_config = Pageflow.config_for(scrolled_entry)
 
       json.partial!('pageflow_scrolled/entry_json_seed/entry',
                     entry: scrolled_entry,
-                    entry_config: Pageflow.config_for(scrolled_entry),
+                    entry_config:,
                     storylines: scrolled_entry_json_seed_storylines(revision),
                     chapters: scrolled_entry_json_seed_chapters(revision, options),
                     sections:,
-                    content_elements: scrolled_entry_json_seed_content_elements(revision, sections),
+                    content_elements:,
+                    file_reference_locations: EntryFileReferenceLocations.new(
+                      entry_config,
+                      content_elements,
+                      include_unused: options[:include_unused_file_reference_locations]
+                    ),
                     widgets: scrolled_entry.resolve_widgets(insert_point: :react),
                     options:)
     end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/i18n_helper.rb

@@ -1,16 +1,23 @@
 module PageflowScrolled
   # @api private
   module I18nHelper
-    def scrolled_i18n_translations(entry, include_inline_editing: false)
-      result = scrolled_i18n_public_translations(entry)
+    def scrolled_i18n_translations(entry,
+                                   ui_locale: I18n.locale,
+                                   include_inline_editing: false,
+                                   include_review: false)
+      ui_scopes = []
+      ui_scopes << :inline_editing if include_inline_editing
+      ui_scopes << :review if include_review
 
-      return result unless include_inline_editing
-
-      result.deep_merge(I18n.locale.to_s => {
-                          pageflow_scrolled: {
-                            inline_editing: I18n.t('pageflow_scrolled.inline_editing')
-                          }
-                        })
+      ui_scopes.reduce(scrolled_i18n_public_translations(entry)) do |result, scope|
+        result.deep_merge(
+          ui_locale.to_s => {
+            pageflow_scrolled: {
+              scope => I18n.t("pageflow_scrolled.#{scope}", locale: ui_locale)
+            }
+          }
+        )
+      end
     end
 
     private
@@ -19,11 +26,19 @@ module PageflowScrolled
       value.presence || fallback
     end
 
+    # Entry locales are not expected to be complete. Merge translations
+    # of all fallback locales since the frontend does not know about
+    # fallbacks.
     def scrolled_i18n_public_translations(entry)
-      translations =
-        I18n.t('pageflow_scrolled.public', locale: I18n.default_locale, default: {})
-            .deep_merge(I18n.t('pageflow_scrolled.public', locale: entry.locale, default: {}),
-                        &MERGE_IGNORING_NIL)
+      locales = [I18n.default_locale, *I18n.fallbacks[entry.locale].reverse].uniq &
+                I18n.available_locales
+
+      translations = locales.reduce({}) do |result, locale|
+        result.deep_merge(
+          I18n.t('pageflow_scrolled.public', locale:, default: {}),
+          &MERGE_IGNORING_NIL
+        )
+      end
 
       {
         entry.locale => {

data/entry_types/scrolled/app/helpers/pageflow_scrolled/packs_helper.rb

@@ -4,17 +4,24 @@ module PageflowScrolled
     def scrolled_frontend_javascript_packs_tag(entry, options)
       javascript_pack_tag(
         *scrolled_frontend_packs(entry, **options),
-        defer: false
+        defer: true
       )
     end
 
-    def scrolled_frontend_stylesheet_packs_tag(entry, options)
+    def scrolled_frontend_stylesheet_packs_tag(entry, **)
       stylesheet_pack_tag(
-        *scrolled_frontend_packs(entry, **options),
+        *scrolled_frontend_stylesheet_packs(entry, **),
         media: 'all'
       )
     end
 
+    def scrolled_frontend_stylesheet_packs(entry, entry_mode:, seed_options: {})
+      packs = scrolled_frontend_packs(entry, entry_mode:, format: :css)
+      packs += ['pageflow-scrolled-frontend-inlineEditing'] if seed_options[:load_inline_editing]
+      packs += ['pageflow-scrolled-frontend-commenting'] if seed_options[:load_commenting]
+      packs
+    end
+
     def scrolled_editor_javascript_packs_tag(entry)
       javascript_pack_tag(
         *scrolled_editor_packs(entry),
@@ -29,10 +36,10 @@ module PageflowScrolled
       )
     end
 
-    def scrolled_frontend_packs(entry, widget_scope:)
+    def scrolled_frontend_packs(entry, entry_mode:, format: :js)
       ['pageflow-scrolled-frontend'] +
-        scrolled_additional_frontend_packs(entry, widget_scope) +
-        scrolled_frontend_widget_type_packs(entry, widget_scope)
+        scrolled_additional_frontend_packs(entry, entry_mode) +
+        scrolled_frontend_widget_type_packs(entry, entry_mode, format)
     end
 
     def scrolled_editor_packs(entry)
@@ -43,7 +50,8 @@ module PageflowScrolled
     end
 
     def scrolled_editor_stylesheet_packs(entry)
-      Pageflow.config_for(entry).additional_editor_packs.stylesheet_paths(entry) +
+      ['pageflow-scrolled-editor'] +
+        Pageflow.config_for(entry).additional_editor_packs.stylesheet_paths(entry) +
         Pageflow.config_for(entry).additional_frontend_packs.paths(entry)
     end
 
@@ -62,15 +70,22 @@ module PageflowScrolled
       )
     end
 
-    def scrolled_frontend_widget_type_packs(entry, widget_scope)
-      scrolled_frontend_pack_widget_types(entry, widget_scope).map(&:pack)
+    def scrolled_frontend_widget_type_packs(entry, widget_scope, format = :js)
+      scrolled_frontend_pack_widget_types(entry, widget_scope)
+        .select { |widget_type| widget_type.respond_to?(:packs) }
+        .flat_map { |widget_type| widget_type.packs(entry:, request:) }
+        .filter_map { |pack|
+          path, stylesheet = pack.is_a?(Hash) ? pack.values_at(:path, :stylesheet) : [pack, false]
+          path if format == :js || stylesheet
+        }
+        .uniq
     end
 
     def scrolled_frontend_pack_widget_types(entry, widget_scope)
       if widget_scope == :editor
-        ReactWidgetType.all_for(entry)
+        Pageflow.config_for(entry).widget_types.select(&:enabled_in_editor?)
       else
-        entry.resolve_widgets(insert_point: :react).map(&:widget_type)
+        entry.resolve_widgets.map(&:widget_type)
       end
     end
   end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/react_server_side_rendering_helper.rb

@@ -4,9 +4,9 @@ module PageflowScrolled
     include Pageflow::RenderJsonHelper
     include PageflowScrolled::EntryJsonSeedHelper
 
-    def render_scrolled_entry(entry)
+    def render_scrolled_entry(entry, options = {})
       seed_json = render_json do |json|
-        scrolled_entry_json_seed(json, entry)
+        scrolled_entry_json_seed(json, entry, options)
       end
 
       ReactServerSideRenderingHelper.renderer.render('Root', "{seed: #{seed_json}}", {})

data/entry_types/scrolled/app/helpers/pageflow_scrolled/sprockets_helper.rb

@@ -0,0 +1,16 @@
+module PageflowScrolled
+  # @api private
+  module SprocketsHelper
+    def scrolled_sprockets_asset_tags(entry, entry_mode:)
+      tags = []
+
+      if Pageflow.config_for(entry).include_legacy_frontend_javascript
+        tags << javascript_include_tag('pageflow_scrolled/legacy')
+      end
+
+      tags << stylesheet_link_tag('pageflow_scrolled/ui', media: 'all') if entry_mode != :published
+
+      safe_join(tags)
+    end
+  end
+end

data/entry_types/scrolled/app/helpers/pageflow_scrolled/themes_helper.rb

@@ -32,6 +32,7 @@ module PageflowScrolled
       ].flatten
 
       content_tag('style', raw(<<~CSS), data: {theme: ''})
+        #{scrolled_theme_font_face_rules(theme)}
         :root {
           #{declarations.join("\n")}
         }
@@ -41,6 +42,23 @@ module PageflowScrolled
       CSS
     end
 
+    def scrolled_theme_font_face_rules(theme)
+      scrolled_theme_font_faces(theme).filter_map(&:generate).join("\n")
+    end
+
+    def scrolled_theme_font_preload_link_tags(theme)
+      safe_join(
+        scrolled_theme_font_faces(theme).filter_map(&:preload_source).map do |source|
+          tag.link(rel: 'preload',
+                   as: 'font',
+                   type: source[:type],
+                   href: source[:url],
+                   crossorigin: 'anonymous',
+                   data: {theme: ''})
+        end
+      )
+    end
+
     def scrolled_theme_typography_rules(theme)
       RuleSet.new(prefix: 'typography').generate(theme.options.fetch(:typography, {}))
     end
@@ -52,6 +70,159 @@ module PageflowScrolled
 
     private
 
+    def scrolled_theme_font_faces(theme)
+      theme.options.fetch(:font_faces, []).map do |face|
+        FontFaceRule.new(face, theme:) { |path| scrolled_theme_asset_path(theme, path) }
+      end
+    end
+
+    # @api private
+    class FontFaceRule
+      FORMATS = {
+        '.woff2' => 'woff2',
+        '.woff' => 'woff',
+        '.ttf' => 'truetype',
+        '.otf' => 'opentype'
+      }.freeze
+
+      MIME_TYPES = {
+        'woff2' => 'font/woff2',
+        'woff' => 'font/woff',
+        'truetype' => 'font/ttf',
+        'opentype' => 'font/otf'
+      }.freeze
+
+      WEIGHT_PATTERN = /\A(normal|bold|\d{1,4}( \d{1,4})?)\z/
+      STYLE_PATTERN = /\A(normal|italic)\z/
+      FORMAT_PATTERN = /\A(woff2?|truetype|opentype|embedded-opentype|svg)(-variations)?\z/
+      UNICODE_RANGE_PATTERN = /\A\s*U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?
+                               (\s*,\s*U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?)*\s*\z/xi
+
+      # Quotes and backslashes would allow breaking out of the quoted
+      # strings family names and urls are interpolated into.
+      UNSAFE_IN_FAMILY = /["'\\[[:cntrl:]]]/
+      UNSAFE_IN_URL = /["'\\\s]/
+
+      ABSOLUTE_URL = %r{\A((https?:)?//|/|data:)}
+
+      def initialize(face, theme:, &resolve_path)
+        @face = face
+        @theme = theme
+        @resolve_path = resolve_path
+      end
+
+      def generate
+        return unless valid?
+
+        <<~CSS
+          @font-face {
+            #{declarations.join("\n  ")}
+          }
+        CSS
+      end
+
+      # Only the first source is preloaded since the browser downloads
+      # exactly one of the alternative formats.
+      def preload_source
+        return unless valid? && face[:preload]
+
+        source = sources_with_safe_urls.first
+
+        {url: source[:url], type: mime_type(source)}
+      end
+
+      private
+
+      attr_reader :face, :theme
+
+      def valid?
+        family.present? && sources_with_safe_urls.any?
+      end
+
+      def declarations
+        [
+          %(font-family: "#{family}";),
+          "src: #{source_values.join(', ')};",
+          'font-display: swap;',
+          *descriptors
+        ]
+      end
+
+      def family
+        @family ||= face[:family].to_s.gsub(UNSAFE_IN_FAMILY, '').strip
+      end
+
+      def source_values
+        sources_with_safe_urls.map { |source| source_value(source) }
+      end
+
+      def sources_with_safe_urls
+        @sources_with_safe_urls ||= sources.reject { |source| source[:url].match?(UNSAFE_IN_URL) }
+      end
+
+      def sources
+        if face[:file_role]
+          sources_from_files
+        else
+          sources_from_src
+        end
+      end
+
+      def sources_from_files
+        Array(face[:file_role]).compact.filter_map do |role|
+          url = theme.files.dig(role.to_sym, :original)
+          {url: url.to_s, format: face[:format]} if url
+        end
+      end
+
+      def sources_from_src
+        Array(face[:src]).filter_map do |src|
+          src = {url: src} unless src.is_a?(Hash)
+          next if src[:url].blank?
+
+          {url: resolve_url(src[:url]), format: src.fetch(:format, face[:format])}
+        end
+      end
+
+      def resolve_url(url)
+        return url.to_s if url.to_s.match?(ABSOLUTE_URL)
+
+        @resolve_path.call(url).to_s
+      end
+
+      def source_value(source)
+        format = source_format(source)
+
+        return %(url("#{source[:url]}")) unless format
+
+        %(url("#{source[:url]}") format("#{format}"))
+      end
+
+      def mime_type(source)
+        MIME_TYPES[source_format(source).to_s.delete_suffix('-variations')]
+      end
+
+      def source_format(source)
+        [source[:format], FORMATS[extension(source[:url])]].find do |candidate|
+          candidate.to_s.match?(FORMAT_PATTERN)
+        end
+      end
+
+      def extension(url)
+        File.extname(url.split(/[?#]/).first.to_s).downcase
+      end
+
+      def descriptors
+        [
+          ['font-weight', face[:weight], WEIGHT_PATTERN],
+          ['font-style', face[:style], STYLE_PATTERN],
+          ['unicode-range', face[:unicode_range], UNICODE_RANGE_PATTERN]
+        ].filter_map do |property, value, pattern|
+          "#{property}: #{value.to_s.strip};" if value.to_s.match?(pattern)
+        end
+      end
+    end
+
     BREAKPOINTS = {
       sm: '640px',
       md: '768px',
@@ -83,8 +254,8 @@ module PageflowScrolled
       private
 
       def extract_breakpoint_declarations!(declarations)
-        BREAKPOINTS.keys.each_with_object({}) { |breakpoint_name, result|
-          result[breakpoint_name] = declarations.delete(breakpoint_name)
+        BREAKPOINTS.keys.to_h { |breakpoint_name|
+          [breakpoint_name, declarations.delete(breakpoint_name)]
         }.compact
       end
 
@@ -128,7 +299,7 @@ module PageflowScrolled
 
     def extract_theme_directory_from_scrolled_theme_asset_path(theme, path)
       if path.starts_with?('../shared/')
-        ['shared', path.gsub!('../shared/', '')]
+        ['shared', path.sub('../shared/', '')]
       elsif path.starts_with?('../')
         raise(ArgumentError,
               'Upward navigation to other directory than the shared ' \