idml 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f43caa091c83d9d8288f22f3913d21760bf5a5dac986f76b72521bb19f5110e0
-  data.tar.gz: 4e33ef7a0c119936d16c0eecb687d153e04d9dc29d789511633fb6fff7f1a152
+  metadata.gz: c6cc7058e67830e2dc6ea523ea6ca054f702ce29b51989a19deb023e5a840bee
+  data.tar.gz: 434b5af5ea49b9f2b48728b100b612ff0cd784079abfd6d419dbeb16554b3ebb
 SHA512:
-  metadata.gz: 16b0f93a7c8993c5f98ad84c6e186ed61ebcaaabcdda63b26c9d1e4bfadd1c3986bef933d2a832d2b3463ab5b23324778a37e92e62cbeb8ce0876dbc26bebcbe
-  data.tar.gz: 9950c7afceda42f377e0d2bef226c4caa346c9d79ac4b3b61dcba99612a321c646eecd6b341be88fd7f8a46c695ecc2449d1bf4d900e4338ed1a4c9f76ea4d45
+  metadata.gz: a59cabfafa44138cb40ed8b6e493396c110ffe43728c0d0ea94d8ef4d8039efad635ba23660852b1040b58ce7141b6e301bf27ecb96599efd6d72069e6d81a95
+  data.tar.gz: d142ebcfc9eb6591827c72d3cd33303ee3a4c70637031b03622ea1355d453cac4aac1654f60ee7a3ee54a050755e88fb84c32c01df11df802c434442c0f9a4e2

data/TODO.pdf/108-multi-frame-story-flow.md

@@ -1,6 +1,10 @@
 # TODO PDF 108: Multi-frame story flow (use StoryThreader)
 
-## Status: OPEN — gap identified in 2026-08-09 audit
+## Status: DONE — `Render::StoryChainController` threads paragraph/run
+state across linked TextFrames. TextFrameRenderer no longer treats
+chain non-heads as standalone; it picks up leftover state from the
+controller, renders what fits, and stores the new leftover for the
+next frame. Overflow text is no longer silently dropped.
 
 ## Problem
 

data/TODO.pdf/110-conditional-text.md

@@ -1,6 +1,12 @@
 # TODO PDF 110: Conditional text (AppliedConditions)
 
-## Status: OPEN — gap identified in 2026-08-09 audit
+## Status: DONE — `Elements::Condition` models the `<Condition>`
+element from designmap.rnc. `Render::ConditionFilter` indexes
+conditions by Self and answers `visible?(applied_conditions_string)`
+per run. `StyleResolver.extract_paragraphs` takes optional
+`condition_filter:` kwarg and drops PSRs/CSRs whose AppliedConditions
+reference a hidden Condition. Pipeline constructs the filter from
+`designmap.condition` and threads it through RenderContext.
 
 ## Problem
 

data/lib/idml/elements/condition.rb

@@ -0,0 +1,31 @@
+# frozen_string: true
+
+module Idml
+  module Elements
+    # `<Condition>` — a single condition declared in `designmap.xml`.
+    # Authors tag text runs with one or more conditions (the CSR's
+    # `AppliedConditions` attribute is a list of condition Self IDs).
+    # The condition's `Visible` flag controls whether tagged text
+    # appears in the rendered output.
+    #
+    # Schema: `Condition_Object` in
+    # `reference-docs/schemas/package/designmap.rnc`.
+    class Condition < Lutaml::Model::Serializable
+      attribute :self_attr, :string
+      attribute :name, :string
+      attribute :indicator_method, :string
+      attribute :underline_indicator_appearance, :string
+      attribute :visible, :boolean, default: true
+
+      xml do
+        root "Condition"
+        map_attribute "Self", to: :self_attr
+        map_attribute "Name", to: :name
+        map_attribute "IndicatorMethod", to: :indicator_method
+        map_attribute "UnderlineIndicatorAppearance",
+                      to: :underline_indicator_appearance
+        map_attribute "Visible", to: :visible
+      end
+    end
+  end
+end

data/lib/idml/elements.rb

@@ -17,6 +17,7 @@ module Idml
     autoload :ButtonPreference, "idml/elements/pref_button_preference"
     autoload :Bookmark, "idml/elements/bookmark"
     autoload :Cell, "idml/elements/cell"
+    autoload :Condition, "idml/elements/condition"
     autoload :CellStyle, "idml/elements/cell_style"
     autoload :CellStyleGroup, "idml/elements/cell_style_group"
     autoload :ChapterNumberPreference,

data/lib/idml/parts/designmap.rb

@@ -48,6 +48,7 @@ module Idml
 
       attribute :layer, Idml::Elements::Layer, collection: true
       attribute :bookmark, Idml::Elements::Bookmark, collection: true
+      attribute :condition, Idml::Elements::Condition, collection: true
       attribute :hyperlink, Idml::Elements::Hyperlink, collection: true
       attribute :hyperlink_page_destination,
                 Idml::Elements::HyperlinkPageDestination, collection: true
@@ -92,6 +93,7 @@ module Idml
         map_attribute "ActiveProcess", to: :active_process
         map_element "Layer", to: :layer
         map_element "Bookmark", to: :bookmark
+        map_element "Condition", to: :condition
         map_element "Hyperlink", to: :hyperlink
         map_element "HyperlinkPageDestination",
                     to: :hyperlink_page_destination

data/lib/idml/render/condition_filter.rb

@@ -0,0 +1,57 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Resolves whether a styled run should render based on its
+    # AppliedConditions and the visibility flags declared on the
+    # corresponding `<Condition>` elements in `designmap.xml`.
+    #
+    # A run is visible when either:
+    # - It has no AppliedConditions (the common case), OR
+    # - Every condition it references is itself Visible.
+    #
+    # A run is hidden when ANY referenced condition is hidden. This
+    # matches InDesign's "hide any text the user has toggled off"
+    # semantics.
+    #
+    # Construction: `ConditionFilter.from_designmap(designmap)`
+    # reads the condition collection and indexes by Self. Use
+    # `filter.visible?(applied_conditions_string)` per run; pass nil
+    # or empty string for untagged runs.
+    class ConditionFilter
+      def self.from_designmap(designmap)
+        conditions = designmap ? designmap.condition : []
+        new(conditions)
+      end
+
+      def initialize(conditions)
+        @visibility_by_self = conditions.to_h do |cond|
+          [cond.self_attr, condition_visible?(cond)]
+        end
+      end
+
+      # `applied_conditions` is the raw PSR/CSR string. IDML encodes
+      # it as a space-separated list of condition Self IDs. Returns
+      # true when the run should render.
+      def visible?(applied_conditions)
+        return true if applied_conditions.nil?
+        return true if applied_conditions.strip.empty?
+
+        applied_conditions.split.uniq.all? do |cond_self|
+          condition_visible?(cond_self)
+        end
+      end
+
+      private
+
+      # A condition is visible when explicitly Visible="true" OR when
+      # the Visibility flag is unset (default true). Only an explicit
+      # Visible="false" hides it.
+      def condition_visible?(cond_or_self)
+        return @visibility_by_self.fetch(cond_or_self, true) if cond_or_self.is_a?(String)
+
+        cond_or_self.visible.nil? || cond_or_self.visible
+      end
+    end
+  end
+end

data/lib/idml/render/pipeline.rb

@@ -38,6 +38,7 @@ module Idml
         structure = StructureTracker.new(enabled: @tagged)
         position_tracker = PositionTracker.new
         layer_filter = LayerFilter.from_designmap(@package.designmap)
+        condition_filter = ConditionFilter.from_designmap(@package.designmap)
         font_ref_resolver = FontReferenceResolver.build(@package)
         font_setup = FontSetup.new(package: @package,
                                    font_search_paths: @font_search_paths)
@@ -50,7 +51,8 @@ module Idml
           page_index = render_spread(writer, spread, layer_filter,
                                      font_ref_resolver, font_resource,
                                      font_metrics, font_map, structure,
-                                     position_tracker, page_index)
+                                     position_tracker, condition_filter,
+                                     page_index)
         end
 
         structure.flush(writer)
@@ -90,14 +92,14 @@ module Idml
 
       def render_spread(writer, spread, layer_filter, font_ref_resolver,
                         font_resource, font_metrics, font_map, structure,
-                        position_tracker, page_offset)
+                        position_tracker, condition_filter, page_offset)
         pages = spread.spread.flat_map(&:page)
         image_refs = ImageCollector.new(writer: writer,
                                         base_dir: File.dirname(@package.path),
                                         page_height: DEFAULT_HEIGHT).collect(spread)
         renderer = build_renderer(layer_filter, font_ref_resolver,
                                   font_resource, font_metrics, font_map,
-                                  structure, position_tracker)
+                                  structure, position_tracker, condition_filter)
         current = page_offset
 
         pages.each do |page|
@@ -126,7 +128,8 @@ module Idml
       end
 
       def build_renderer(layer_filter, font_ref_resolver, font_resource,
-                         font_metrics, font_map, structure, position_tracker)
+                         font_metrics, font_map, structure, position_tracker,
+                         condition_filter)
         SpreadRenderer.new(
           font_metrics: font_metrics,
           font_ps_name: font_resource,
@@ -136,6 +139,7 @@ module Idml
           font_ref_resolver: font_ref_resolver,
           structure: structure,
           position_tracker: position_tracker,
+          condition_filter: condition_filter,
         )
       end
 

data/lib/idml/render/render_context.rb

@@ -20,6 +20,8 @@ module Idml
       :structure,
       :page_index,
       :position_tracker,
+      :chain_controller,
+      :condition_filter,
       keyword_init: true,
     )
   end

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -30,7 +30,6 @@ module Idml
         def self.render(canvas, context)
           frame = context.item
           return unless frame.parent_story
-          return unless chain_head?(frame)
 
           story = context.package&.story_by_id(frame.parent_story)
           return unless story
@@ -38,12 +37,53 @@ module Idml
           box = frame_box(frame, context.page_height)
           render_inline_tables(canvas, story, box, context)
 
-          paragraphs = StyleResolver.extract_paragraphs(story)
-          return if paragraphs.empty?
+          state = initial_chain_state(frame, story, context)
+          return unless state
 
-          render_text(canvas, paragraphs, context, box)
+          render_text(canvas, state, context, box)
+          store_chain_state(frame, state, context)
         end
 
+        # Returns the StoryChainController::State to render this frame
+        # with. For chain heads (no predecessor), this is a fresh
+        # state built from extract_paragraphs. For chain non-heads,
+        # this is the leftover state from the previous frame in the
+        # chain (nil when there's nothing left to render).
+        def self.initial_chain_state(frame, story, context)
+          controller = context.chain_controller
+          return fresh_state(story, context) if chain_head?(frame)
+          return nil unless controller
+
+          controller.state_for(frame.parent_story)
+        end
+        private_class_method :initial_chain_state
+
+        # Records the post-render state for the chain so the next
+        # frame in the chain picks up where this one left off. Only
+        # meaningful when a chain_controller is wired.
+        def self.store_chain_state(frame, state, context)
+          controller = context.chain_controller
+          return unless controller
+
+          controller.store_state(frame.parent_story, state)
+        end
+        private_class_method :store_chain_state
+
+        def self.fresh_state(story, context)
+          paragraphs = StyleResolver.extract_paragraphs(
+            story, condition_filter: context.condition_filter
+          )
+          return nil if paragraphs.empty?
+
+          StoryChainController::State.new(
+            paragraphs: paragraphs,
+            current_paragraph: nil,
+            runs_remaining: [],
+            char_cursor: 0,
+          )
+        end
+        private_class_method :fresh_state
+
         # Discovers Tables inlined in the story (Story > PSR > CSR >
         # Table — the real IDML structure) and renders each within
         # the frame's bounds. Real IDML Tables have no own geometry,
@@ -70,12 +110,12 @@ module Idml
         end
         private_class_method :tables_in_story
 
-        def self.render_text(canvas, paragraphs, context, box)
+        def self.render_text(canvas, state, context, box)
           font = context.font_metrics
           if font
-            engine_render(canvas, paragraphs, context, box, font)
+            engine_render(canvas, state, context, box, font)
           else
-            simple_render(canvas, paragraphs, context, box)
+            simple_render(canvas, state, context, box)
           end
         end
         private_class_method :render_text
@@ -109,56 +149,150 @@ module Idml
         end
         private_class_method :layout_frame
 
-        # Walks paragraphs and emits one `canvas.text` per line via
-        # the Shaper → LineBreaker → Justifier → VerticalLayout
-        # pipeline. Cursor y descends monotonically across
-        # paragraphs so text flows top-to-bottom (the previous
-        # implementation reset every run to the frame top).
-        def self.engine_render(canvas, paragraphs, context, box, font)
+        # Walks the chain state's paragraphs/runs and emits one
+        # `canvas.text` per line via the Shaper → LineBreaker →
+        # Justifier → VerticalLayout pipeline. Cursor y descends
+        # monotonically across paragraphs. When a paragraph partially
+        # fits, its remaining runs go back into the state for the
+        # next frame in the chain.
+        def self.engine_render(canvas, state, context, box, font)
           layout_frame = layout_frame(context.item, box)
           cursor_y = box[:y] + box[:height] - (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
-          char_cursor = 0
-
-          paragraphs.each do |paragraph|
-            break if cursor_y < bottom_limit
+          char_cursor = state.char_cursor
 
-            cursor_y, char_cursor = render_paragraph(
-              canvas, paragraph, context, layout_frame, font,
+          if state.current_paragraph
+            cursor_y, char_cursor = resume_paragraph(
+              canvas, state, context, layout_frame, font,
               cursor_y, bottom_limit, char_cursor
             )
+            return if state.current_paragraph
           end
+
+          consume_paragraphs(canvas, state, context, layout_frame, font,
+                             cursor_y, bottom_limit, char_cursor)
         end
         private_class_method :engine_render
 
-        def self.render_paragraph(canvas, paragraph, context, layout_frame,
-                                  font, cursor_y, bottom_limit, char_cursor)
+        def self.resume_paragraph(canvas, state, context, layout_frame, font,
+                                  cursor_y, bottom_limit, char_cursor)
+          paragraph = state.current_paragraph
+          remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
+            canvas, paragraph, state.runs_remaining, context,
+            layout_frame, font, cursor_y, bottom_limit, char_cursor,
+            first_paragraph: true
+          )
+          if remaining_runs.any?
+            state.runs_remaining = remaining_runs
+          else
+            state.current_paragraph = nil
+            state.runs_remaining = []
+          end
+          [cursor_y, char_cursor]
+        end
+        private_class_method :resume_paragraph
+
+        def self.consume_paragraphs(canvas, state, context, layout_frame, font,
+                                    cursor_y, bottom_limit, char_cursor)
+          pending = 0
+          state.paragraphs.each do |paragraph|
+            break if cursor_y < bottom_limit
+
+            remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
+              canvas, paragraph, paragraph.runs, context,
+              layout_frame, font, cursor_y, bottom_limit, char_cursor,
+              first_paragraph: pending.zero?
+            )
+            if remaining_runs.any?
+              state.current_paragraph = paragraph
+              state.runs_remaining = remaining_runs
+              break
+            end
+            pending += 1
+          end
+
+          state.paragraphs = state.paragraphs[pending..]
+          state.char_cursor = char_cursor
+        end
+        private_class_method :consume_paragraphs
+
+        # Renders a paragraph's runs (a subset when resuming mid-para).
+        # Returns [remaining_runs, cursor_y, char_cursor] where
+        # remaining_runs is the runs that didn't fit (empty when all
+        # done). Emits RuleAbove before the first run and RuleBelow
+        # after the last successfully-rendered run.
+        def self.render_runs_for_paragraph(canvas, paragraph, runs, context,
+                                           layout_frame, font, cursor_y,
+                                           bottom_limit, char_cursor,
+                                           first_paragraph:)
           wrap_width = TextEngine::VerticalLayout.wrap_width(
             layout_frame, paragraph.right_indent || 0
           )
           para_attrs = paragraph_attrs(paragraph)
           frame_left, frame_right = paragraph_frame_extents(layout_frame)
 
-          # RuleAbove sits at the paragraph's top edge (before
-          # space_before is subtracted), so emit it first using the
-          # incoming cursor_y as the anchor.
+          emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
+                                  frame_left, frame_right, first_paragraph)
+
+          rendered_count = 0
+          runs.each do |run|
+            break if cursor_y < bottom_limit
+
+            space_before = paragraph_space_before(para_attrs, first_paragraph,
+                                                  rendered_count)
+            positioned, next_y = layout_run(
+              canvas, run, paragraph, context, layout_frame, font,
+              wrap_width, cursor_y, space_before,
+              para_attrs[:first_line_indent], para_attrs[:left_indent],
+              char_cursor
+            )
+            char_cursor += positioned.length
+            cursor_y = next_y
+            rendered_count += 1
+          end
+
+          remaining_runs = runs[rendered_count..]
+          cursor_y = emit_paragraph_bottom_rule(canvas, paragraph, context,
+                                                cursor_y, frame_left,
+                                                frame_right, para_attrs,
+                                                remaining_runs)
+          [remaining_runs, cursor_y, char_cursor]
+        end
+        private_class_method :render_runs_for_paragraph
+
+        def self.emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
+                                         frame_left, frame_right,
+                                         first_paragraph)
+          return unless first_paragraph
+
           ParagraphRules.emit_rule_above(canvas, paragraph, context,
                                          cursor_y, frame_left, frame_right)
+        end
+        private_class_method :emit_paragraph_top_rule
 
-          cursor_y, char_cursor = render_runs(
-            canvas, paragraph, context, layout_frame, font,
-            wrap_width, cursor_y, bottom_limit, char_cursor, para_attrs
-          )
-          after_y = cursor_y - para_attrs[:space_after]
+        def self.paragraph_space_before(para_attrs, first_paragraph,
+                                        rendered_count)
+          return 0 unless first_paragraph && rendered_count.zero?
+
+          para_attrs[:space_before]
+        end
+        private_class_method :paragraph_space_before
 
-          # RuleBelow sits at the paragraph's bottom edge (after the
-          # last line + space_after), so emit it last using after_y
-          # as the anchor.
+        # Emits RuleBelow after a paragraph's last run. Returns the
+        # updated cursor_y (subtracting space_after when the paragraph
+        # completed).
+        def self.emit_paragraph_bottom_rule(canvas, paragraph, context,
+                                            cursor_y, frame_left,
+                                            frame_right, para_attrs,
+                                            remaining_runs)
+          return cursor_y unless remaining_runs.empty?
+
+          after_y = cursor_y - para_attrs[:space_after]
           ParagraphRules.emit_rule_below(canvas, paragraph, context,
                                          after_y, frame_left, frame_right)
-          [after_y, char_cursor]
+          after_y
         end
-        private_class_method :render_paragraph
+        private_class_method :emit_paragraph_bottom_rule
 
         def self.paragraph_frame_extents(layout_frame)
           inset_left = layout_frame.inset_left || 0
@@ -178,27 +312,6 @@ module Idml
         end
         private_class_method :paragraph_attrs
 
-        def self.render_runs(canvas, paragraph, context, layout_frame, font,
-                             wrap_width, cursor_y, bottom_limit, char_cursor,
-                             para_attrs)
-          space_before = para_attrs[:space_before]
-          paragraph.runs.each do |run|
-            break if cursor_y < bottom_limit
-
-            positioned, next_y = layout_run(
-              canvas, run, paragraph, context, layout_frame, font,
-              wrap_width, cursor_y, space_before,
-              para_attrs[:first_line_indent], para_attrs[:left_indent],
-              char_cursor
-            )
-            char_cursor += positioned.length
-            cursor_y = next_y
-            space_before = 0
-          end
-          [cursor_y, char_cursor]
-        end
-        private_class_method :render_runs
-
         # Shapes one run's text, wraps to the inset/indent-adjusted
         # width, justifies per paragraph alignment, and asks
         # VerticalLayout to position the lines. Emits each line via
@@ -321,8 +434,11 @@ module Idml
 
         # Fallback when no metrics are available: emit all runs as
         # one `text_rich` block, letting pdfrb measure advance widths.
-        def self.simple_render(canvas, paragraphs, context, box)
-          runs = paragraphs.flat_map(&:runs)
+        # Chain threading is best-effort here — the simple path
+        # doesn't wrap, so the first frame's render typically emits
+        # all content and clears the chain state.
+        def self.simple_render(canvas, state, context, box)
+          runs = collect_runs(state)
           return if runs.empty?
 
           runs_for = build_rich_runs(runs, context)
@@ -331,9 +447,22 @@ module Idml
             runs_for,
             at: [box[:x], box[:y] + box[:height] - first_size],
           )
+          state.paragraphs = []
+          state.current_paragraph = nil
+          state.runs_remaining = []
         end
         private_class_method :simple_render
 
+        def self.collect_runs(state)
+          runs = state.runs_remaining || []
+          if state.current_paragraph
+            runs + state.current_paragraph.runs
+          else
+            runs + state.paragraphs.flat_map(&:runs)
+          end
+        end
+        private_class_method :collect_runs
+
         def self.build_rich_runs(runs, context)
           runs.map do |run|
             {

data/lib/idml/render/spread_renderer.rb

@@ -7,7 +7,8 @@ module Idml
       def initialize(font_metrics: nil, font_ps_name: Render::DEFAULT_FONT,
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil,
-                     position_tracker: nil, font_map: {})
+                     position_tracker: nil, font_map: {},
+                     condition_filter: nil)
         @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
@@ -16,6 +17,7 @@ module Idml
         @structure = structure
         @position_tracker = position_tracker
         @font_map = font_map
+        @condition_filter = condition_filter
       end
 
       def render(canvas, spread, page_width:, page_height:, image_refs: [],
@@ -33,6 +35,8 @@ module Idml
           structure: @structure,
           page_index: page_index,
           position_tracker: @position_tracker,
+          chain_controller: StoryChainController.new,
+          condition_filter: @condition_filter,
         }
 
         canvas.save_graphics_state do

data/lib/idml/render/story_chain_controller.rb

@@ -0,0 +1,66 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Threads story-rendering state across linked TextFrames in a
+    # chain. A story overflows from frame 1 → frame 2 → frame 3 etc.
+    # via PreviousTextFrame/NextTextFrame links; without chain
+    # awareness, the renderer would silently truncate overflow text.
+    #
+    # State is per story_id (the ParentStory attribute). State is
+    # populated when a chain head renders and consumed when chain
+    # non-head frames render.
+    #
+    # Threading granularity: paragraphs and runs. If a run partially
+    # fits in a frame, the next frame picks up where the previous
+    # left off (the partially-rendered lines stay in the previous
+    # frame; remaining lines come from re-wrapping the run).
+    class StoryChainController
+      # `paragraphs` : Array<Paragraph> not yet started
+      # `current_paragraph` : Paragraph in progress (nil if none)
+      # `runs_remaining` : Array<StyledRun> in current_paragraph not yet rendered
+      # `char_cursor` : global character cursor (for hyperlink tracking)
+      State = Struct.new(
+        :paragraphs,
+        :current_paragraph,
+        :runs_remaining,
+        :char_cursor,
+        keyword_init: true,
+      )
+
+      def initialize
+        @states = {}
+      end
+
+      # Returns the chain state for a story, or nil if the story has
+      # no leftover content. Chain heads (no predecessor) get no
+      # state — they render from scratch.
+      def state_for(story_id)
+        @states[story_id]
+      end
+
+      # Records the chain state for a story after a frame's render.
+      # Removes the state entirely when no content remains.
+      def store_state(story_id, state)
+        if state.nil? || empty_state?(state)
+          @states.delete(story_id)
+        else
+          @states[story_id] = state
+        end
+      end
+
+      # True when a story has pending content from a previous frame.
+      def has_pending?(story_id)
+        @states.key?(story_id)
+      end
+
+      private
+
+      def empty_state?(state)
+        state.paragraphs.empty? &&
+          state.current_paragraph.nil? &&
+          state.runs_remaining&.empty?
+      end
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -104,11 +104,13 @@ module Idml
       # its runs and carries the paragraph-level attributes from the
       # owning PSR. Empty paragraphs (no runs after filtering) are
       # skipped.
-      def self.extract_paragraphs(story)
+      def self.extract_paragraphs(story, condition_filter: nil)
         return [] unless story&.inner
 
         story.inner.paragraph_style_range.filter_map do |psr|
-          runs = csr_runs(psr)
+          next unless condition_visible?(psr, condition_filter)
+
+          runs = csr_runs(psr, condition_filter: condition_filter)
           next if runs.empty?
 
           Paragraph.new(
@@ -140,8 +142,10 @@ module Idml
         end
       end
 
-      def self.csr_runs(psr)
+      def self.csr_runs(psr, condition_filter: nil)
         psr.character_style_range.filter_map do |csr|
+          next unless condition_visible?(csr, condition_filter)
+
           text = csr.text_content
           next if text.nil? || text.empty?
 
@@ -170,6 +174,16 @@ module Idml
       end
       private_class_method :csr_runs
 
+      # Drops the PSR/CSR when any of its AppliedConditions
+      # references a hidden Condition. Returns true when no filter
+      # is supplied (caller doesn't care about conditions).
+      def self.condition_visible?(psr_or_csr, condition_filter)
+        return true unless condition_filter
+
+        condition_filter.visible?(psr_or_csr.applied_conditions)
+      end
+      private_class_method :condition_visible?
+
       def self.alignment_for(csr)
         ALIGNMENT_MAP[csr.justification] || :left
       end

data/lib/idml/render.rb

@@ -15,7 +15,9 @@ module Idml
     autoload :StrokeStyle,         "#{__dir__}/render/stroke_style"
     autoload :CharacterStyle,      "#{__dir__}/render/character_style"
     autoload :ParagraphRules,      "#{__dir__}/render/paragraph_rules"
+    autoload :StoryChainController, "#{__dir__}/render/story_chain_controller"
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
+    autoload :ConditionFilter,     "#{__dir__}/render/condition_filter"
     autoload :Placement,           "#{__dir__}/render/placement"
     autoload :ImageCollector,      "#{__dir__}/render/image_collector"
     autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Ribose
@@ -276,6 +276,7 @@ files:
 - lib/idml/elements/character_style_group.rb
 - lib/idml/elements/character_style_range.rb
 - lib/idml/elements/color.rb
+- lib/idml/elements/condition.rb
 - lib/idml/elements/content.rb
 - lib/idml/elements/content_transparency_setting.rb
 - lib/idml/elements/contour_option.rb
@@ -428,6 +429,7 @@ files:
 - lib/idml/render/character_style.rb
 - lib/idml/render/color_helper.rb
 - lib/idml/render/color_resolver.rb
+- lib/idml/render/condition_filter.rb
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/font_setup.rb
 - lib/idml/render/gradient_resolver.rb
@@ -454,6 +456,7 @@ files:
 - lib/idml/render/renderers/table_renderer.rb
 - lib/idml/render/renderers/text_frame_renderer.rb
 - lib/idml/render/spread_renderer.rb
+- lib/idml/render/story_chain_controller.rb
 - lib/idml/render/story_threader.rb
 - lib/idml/render/stroke_style.rb
 - lib/idml/render/structure_mapper.rb