idml 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f60e795f4325dcc4006a28915a18baf7069e21767694ca670c41f84db62d98d
-  data.tar.gz: 4f1f4846d41050b518c8add338ce431951b45ea58891b2c56154b47e59478bc7
+  metadata.gz: bdf6a3aba5bbe199af39e5addabae082b795dfef1583dd14f33a9d7415086ead
+  data.tar.gz: eb1a78bd1a11fdc7500543b903b4d927114a96a70fea97a7e8b4c62db813451e
 SHA512:
-  metadata.gz: bbf7caac497ce2ab01a8c35af7bad78a24b7a706db6baa582b7d416cae1ce4995f18a3903379c4e994ab49ca1f28efd33e162821dead95250ae8248c041d16cd
-  data.tar.gz: ed5d2ae0abf40c0c6bf101d3c05ca35f59bc48aefed14366de7f5ac0f15979ff458ca7cf8493d012c4f6a78b0c1889815f987ea3dc9f24971f31ae34583f6fc4
+  metadata.gz: e47ca1b121cd27336a516f8b0cb863d5ad03edbdc43455bfa3efcb41807865a1dae4aec35ccbf380e003dc383d9f0d3704b42e23efa0d56c6925f316b68030c1
+  data.tar.gz: 3ac803ec48c5a0e2a2e3eec6f17845993a2a3194ddb8046bd5e8ea7225fcd8709abef22817684c12c51814b26a6ca9d3e07f2b4a735b519b9cb3d99e9eaaec5c

data/TODO.pdf/116-applied-style-resolution.md

@@ -0,0 +1,65 @@
+# TODO PDF 116: AppliedParagraphStyle / AppliedCharacterStyle resolution from Resources/Styles.xml
+
+## Status: DONE — `Render::StyleLookup` indexes ParagraphStyle and
+CharacterStyle from Resources/Styles.xml by Self. StyleResolver
+uses it to fill in formatting attributes that PSR/CSR elements don't
+declare inline. PSR/CSR inline attributes override style values.
+
+## Problem
+
+In real IDML documents, the `<ParagraphStyleRange>` element often
+carries ONLY an `AppliedParagraphStyle` reference and NO inline
+formatting attributes. The actual formatting (Justification,
+SpaceBefore, PointSize, etc.) lives in the referenced
+`<ParagraphStyle>` definition in `Resources/Styles.xml`.
+
+Example from the sample-with-table-more fixture:
+```xml
+<ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/$ID/NormalParagraphStyle">
+  <CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]">
+    ...
+  </CharacterStyleRange>
+</ParagraphStyleRange>
+```
+
+The PSR has NO inline Justification, SpaceBefore, etc. Those values
+are on `ParagraphStyle Self="ParagraphStyle/$ID/NormalParagraphStyle"`
+in Styles.xml.
+
+Today StyleResolver reads attributes directly from the PSR element.
+When the PSR has only a style reference (common in real documents),
+the renderer uses default values for everything.
+
+## Impact
+
+For the `sample-with-table-more` fixture, every PSR uses
+`NormalParagraphStyle` — which in InDesign maps to 12pt Regular with
+left alignment. The renderer happens to produce approximately right
+output because the defaults match. But for documents that use custom
+paragraph styles (Heading 1 = 24pt Bold Centered, Body Text = 11pt
+Justified with 6pt SpaceAfter), the output would be wrong.
+
+## What needs to happen
+
+1. `Render::StyleResolver` resolves `AppliedParagraphStyle` to a
+   `ParagraphStyle` from `Parts::Style` (Resources/Styles.xml).
+2. PSR inline attributes override the style's attributes (when both
+   are present — this is the IDML "local override" mechanism).
+3. Same for `AppliedCharacterStyle` → `CharacterStyle` resolution.
+4. The merged attributes become the Paragraph/StyledRun's values.
+
+Architecture: `Parts::Style` already parses `<ParagraphStyle>` and
+`<CharacterStyle>` entries. StyleResolver needs access to the style
+part (via `context.package.styles` or similar).
+
+## Acceptance criteria
+
+- [ ] PSR with only AppliedParagraphStyle resolves formatting from
+      the referenced ParagraphStyle.
+- [ ] PSR inline attributes override style attributes.
+- [ ] CharacterStyle resolution for CSR's AppliedCharacterStyle.
+- [ ] Spec: fixture with custom paragraph style renders correctly.
+
+## Dependencies
+
+- None — pure feature work on existing models.

data/TODO.pdf/99-table-column-widths.md

@@ -1,10 +1,10 @@
-# TODO PDF 99: Table column widths from ColumnAttributes
+# TODO PDF 99: Table column widths from Column elements
 
-## Status: DONE — Table now models `column_count` and
-`single_column_width`; SchemaLayout uses SingleColumnWidth when
-declared, else falls back to even division. (IDML has no separate
-ColumnAttributes element — column widths live on Table directly
-when uniform.)
+## Status: DONE — Table now models both `single_column_width`
+(uniform) and per-column `<Column>` elements with individual
+`SingleColumnWidth` values. SchemaLayout uses per-column widths
+when `<Column>` children are present; falls back to uniform when
+not.
 
 ## Problem
 

data/lib/idml/elements/column.rb

@@ -0,0 +1,45 @@
+# frozen_string: true
+
+module Idml
+  module Elements
+    # `<Column>` — a column definition within an IDML Table. Carries
+    # the column's width (SingleColumnWidth), type (HeaderColumn /
+    # BodyColumn), insets, and visual properties (fill, diagonal lines).
+    #
+    # Schema: `Column_Object` in
+    # `reference-docs/schemas/package/Stories/Story.rnc`. Real IDML
+    # tables have `<Column>` children alongside `<Row>` and `<Cell>`
+    # siblings. The `Name` attribute is the column index as a string
+    # (e.g., "0", "1", "2").
+    #
+    # The renderer's SchemaLayout reads `SingleColumnWidth` per column
+    # to compute per-column x positions and widths (replaces the
+    # even-division / uniform-width fallback).
+    class Column < Lutaml::Model::Serializable
+      attribute :self_attr, :string
+      attribute :name, :string
+      attribute :single_column_width, :float
+      attribute :column_type, :string
+      attribute :fill_color, :string
+      attribute :fill_tint, :float
+
+      xml do
+        root "Column"
+        map_attribute "Self", to: :self_attr
+        map_attribute "Name", to: :name
+        map_attribute "SingleColumnWidth", to: :single_column_width
+        map_attribute "ColumnType", to: :column_type
+        map_attribute "FillColor", to: :fill_color
+        map_attribute "FillTint", to: :fill_tint
+      end
+
+      # Column Name is a string integer (e.g., "0", "1").
+      # Returns the integer index or nil if Name is missing/invalid.
+      def index
+        return nil unless name
+
+        Integer(name, 10, exception: false) # rubocop:disable Style/RescueModifier
+      end
+    end
+  end
+end

data/lib/idml/elements/table.rb

@@ -46,6 +46,7 @@ module Idml
       attribute :table_row, Idml::Elements::TableRow, collection: true
       attribute :cell, Idml::Elements::Cell, collection: true
       attribute :row, Idml::Elements::Row, collection: true
+      attribute :column, Idml::Elements::Column, collection: true
       attribute :properties, Idml::Elements::Properties, collection: true
 
       xml do
@@ -77,6 +78,7 @@ module Idml
         map_element "TableRow", to: :table_row
         map_element "Cell", to: :cell
         map_element "Row", to: :row
+        map_element "Column", to: :column
         map_element "Properties", to: :properties
       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 :Column, "idml/elements/column"
     autoload :Condition, "idml/elements/condition"
     autoload :CellStyle, "idml/elements/cell_style"
     autoload :CellStyleGroup, "idml/elements/cell_style_group"

data/lib/idml/render/pipeline.rb

@@ -39,6 +39,7 @@ module Idml
         position_tracker = PositionTracker.new
         layer_filter = LayerFilter.from_designmap(@package.designmap)
         condition_filter = ConditionFilter.from_designmap(@package.designmap)
+        style_lookup = StyleLookup.from_package(@package)
         font_ref_resolver = FontReferenceResolver.build(@package)
         font_setup = FontSetup.new(package: @package,
                                    font_search_paths: @font_search_paths)
@@ -52,7 +53,7 @@ module Idml
                                      font_ref_resolver, font_resource,
                                      font_metrics, font_map, structure,
                                      position_tracker, condition_filter,
-                                     page_index)
+                                     style_lookup, page_index)
         end
 
         structure.flush(writer)
@@ -92,14 +93,16 @@ module Idml
 
       def render_spread(writer, spread, layer_filter, font_ref_resolver,
                         font_resource, font_metrics, font_map, structure,
-                        position_tracker, condition_filter, page_offset)
+                        position_tracker, condition_filter, style_lookup,
+                        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, condition_filter)
+                                  structure, position_tracker, condition_filter,
+                                  style_lookup)
         current = page_offset
 
         pages.each do |page|
@@ -129,7 +132,7 @@ module Idml
 
       def build_renderer(layer_filter, font_ref_resolver, font_resource,
                          font_metrics, font_map, structure, position_tracker,
-                         condition_filter)
+                         condition_filter, style_lookup)
         SpreadRenderer.new(
           font_metrics: font_metrics,
           font_ps_name: font_resource,
@@ -140,6 +143,7 @@ module Idml
           structure: structure,
           position_tracker: position_tracker,
           condition_filter: condition_filter,
+          style_lookup: style_lookup,
         )
       end
 

data/lib/idml/render/render_context.rb

@@ -22,6 +22,7 @@ module Idml
       :position_tracker,
       :chain_controller,
       :condition_filter,
+      :style_lookup,
       keyword_init: true,
     )
   end

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

@@ -243,7 +243,8 @@ module Idml
                 mark_covered(covered, col_idx, row_idx, col_span, row_span)
 
                 yield cell_x(col_idx), cell_y(row_idx, col_span, row_span),
-                      cell_w(col_span), cell_h(row_idx, row_span), cell
+                      cell_w(col_idx, col_span), cell_h(row_idx, row_span),
+                      cell
               end
             end
           end
@@ -286,7 +287,7 @@ module Idml
           private :mark_covered
 
           def cell_x(col)
-            box[:x] + (col * per_col_width)
+            box[:x] + cumulative_col_width(col)
           end
 
           # PDF-coordinate bottom y of the cell's rectangle. For a
@@ -297,9 +298,11 @@ module Idml
             box[:y] + total_height - cumulative_height(last_row + 1)
           end
 
-          # Width covered by `span` columns starting at the cell's col.
-          def cell_w(span)
-            per_col_width * (span || 1)
+          # Width covered by `span` columns starting at `col`. Uses
+          # per-column widths from Column elements when available;
+          # falls back to uniform width when not.
+          def cell_w(col, span)
+            span.to_i.times.sum { |i| column_width_at(col + i) }
           end
 
           # Total height covered by `span` rows starting at `row_idx`.
@@ -318,6 +321,41 @@ module Idml
                              end
           end
 
+          # Returns per-column widths from Column elements when
+          # present; empty array otherwise. When non-empty, the
+          # renderer uses per-column widths for x positions and
+          # span widths instead of uniform per_col_width.
+          def per_column_widths
+            return @per_column_widths if defined?(@per_column_widths)
+
+            cols = table.column
+            @per_column_widths = if cols.empty?
+                                   []
+                                 else
+                                   cols.filter_map do |col|
+                                     w = col.single_column_width
+                                     w&.positive? ? w : nil
+                                   end
+                                 end
+          end
+
+          # Width of a single column at index `idx`. Uses per-column
+          # widths when available; falls back to uniform.
+          def column_width_at(idx)
+            return per_col_width if per_column_widths.empty?
+            return per_col_width unless idx.between?(0, per_column_widths.length - 1)
+
+            per_column_widths[idx]
+          end
+
+          # Cumulative width from column 0 up to (but not including)
+          # column `col`. Used for x positioning.
+          def cumulative_col_width(col)
+            return col * per_col_width if per_column_widths.empty?
+
+            col.times.sum { |i| column_width_at(i) }
+          end
+
           def row_height(idx)
             return 0.0 unless idx.between?(0, row_count - 1)
 

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

@@ -71,7 +71,8 @@ module Idml
 
         def self.fresh_state(story, context)
           paragraphs = StyleResolver.extract_paragraphs(
-            story, condition_filter: context.condition_filter
+            story, condition_filter: context.condition_filter,
+                   style_lookup: context.style_lookup
           )
           return nil if paragraphs.empty?
 

data/lib/idml/render/spread_renderer.rb

@@ -8,7 +8,7 @@ module Idml
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil,
                      position_tracker: nil, font_map: {},
-                     condition_filter: nil)
+                     condition_filter: nil, style_lookup: nil)
         @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
@@ -18,6 +18,7 @@ module Idml
         @position_tracker = position_tracker
         @font_map = font_map
         @condition_filter = condition_filter
+        @style_lookup = style_lookup
       end
 
       def render(canvas, spread, page_width:, page_height:, image_refs: [],
@@ -37,6 +38,7 @@ module Idml
           position_tracker: @position_tracker,
           chain_controller: StoryChainController.new,
           condition_filter: @condition_filter,
+          style_lookup: @style_lookup,
         }
 
         canvas.save_graphics_state do

data/lib/idml/render/style_lookup.rb

@@ -0,0 +1,78 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Resolves `AppliedParagraphStyle` and `AppliedCharacterStyle`
+    # references to their style definitions in Resources/Styles.xml.
+    # Built once per render pass from `Parts::Style`; StyleResolver
+    # consults it to fill in formatting attributes that the PSR/CSR
+    # element doesn't declare inline.
+    #
+    # Merge semantics: PSR/CSR inline attributes override style
+    # attributes. When the PSR/CSR declares a value (non-nil), that
+    # wins. When it doesn't, the style definition's value is used
+    # as a default. When neither declares a value, the attribute
+    # remains nil and the renderer applies its own default.
+    class StyleLookup
+      def self.from_package(package)
+        styles = package&.style
+        return new({}, {}) unless styles
+
+        para_styles = index_styles(styles.paragraph_style)
+        char_styles = index_styles(styles.character_style)
+        new(para_styles, char_styles)
+      end
+
+      def initialize(para_styles, char_styles)
+        @para_styles = para_styles
+        @char_styles = char_styles
+      end
+
+      # Returns the ParagraphStyle referenced by `self_ref`, or nil.
+      # `self_ref` is the PSR's AppliedParagraphStyle value (e.g.,
+      # "ParagraphStyle/$ID/NormalParagraphStyle").
+      def paragraph_style(self_ref)
+        return nil unless self_ref
+
+        @para_styles[self_ref]
+      end
+
+      # Returns the CharacterStyle referenced by `self_ref`, or nil.
+      def character_style(self_ref)
+        return nil unless self_ref
+
+        @char_styles[self_ref]
+      end
+
+      # Returns the value of `attr_name` from the PSR, or from the
+      # referenced ParagraphStyle when the PSR doesn't declare it.
+      # Uses `public_send` (not `send`) to stay within public API
+      # boundaries — the attribute readers generated by lutaml-model
+      # are public.
+      def resolve_para_attr(psr, attr_name)
+        psr_value = psr.public_send(attr_name)
+        return psr_value unless psr_value.nil?
+
+        style = paragraph_style(psr.applied_paragraph_style)
+        style&.public_send(attr_name)
+      end
+
+      # Returns the value of `attr_name` from the CSR, or from the
+      # referenced CharacterStyle when the CSR doesn't declare it.
+      def resolve_char_attr(csr, attr_name)
+        csr_value = csr.public_send(attr_name)
+        return csr_value unless csr_value.nil?
+
+        style = character_style(csr.applied_character_style)
+        style&.public_send(attr_name)
+      end
+
+      def self.index_styles(collection)
+        collection.each_with_object({}) do |style, hash|
+          hash[style.self_attr] = style if style.self_attr
+        end
+      end
+      private_class_method :index_styles
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -110,53 +110,74 @@ 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, condition_filter: nil)
+      def self.extract_paragraphs(story, condition_filter: nil,
+                                  style_lookup: nil)
         return [] unless story&.inner
 
         story.inner.paragraph_style_range.filter_map do |psr|
           next unless condition_visible?(psr, condition_filter)
 
-          runs = csr_runs(psr, condition_filter: condition_filter)
+          runs = csr_runs(psr, condition_filter: condition_filter,
+                               style_lookup: style_lookup)
           next if runs.empty?
 
           paragraph = Paragraph.new(
             runs: runs,
             alignment: runs.first.alignment,
-            space_before: psr.space_before,
-            space_after: psr.space_after,
-            first_line_indent: psr.first_line_indent,
-            left_indent: psr.left_indent,
-            right_indent: psr.right_indent,
-            auto_leading: psr.auto_leading,
-            drop_cap_lines: psr.drop_cap_lines,
-            drop_cap_characters: psr.drop_cap_characters,
-            bullets_and_numbering_list_type: psr.bullets_and_numbering_list_type,
-            bullet_character_value: psr.bullet_character_value,
-            bullets_text_after: psr.bullets_text_after,
-            numbering_expression: psr.numbering_expression,
-            rule_above: psr.rule_above,
-            rule_above_line_weight: psr.rule_above_line_weight,
-            rule_above_color: psr.stroke_color,
-            rule_above_tint: psr.rule_above_tint,
-            rule_above_offset: psr.rule_above_offset,
-            rule_above_left_indent: psr.rule_above_left_indent,
-            rule_above_right_indent: psr.rule_above_right_indent,
-            rule_above_width: psr.rule_above_width,
-            rule_below: psr.rule_below,
-            rule_below_line_weight: psr.rule_below_line_weight,
-            rule_below_color: psr.stroke_color,
-            rule_below_tint: psr.rule_below_tint,
-            rule_below_offset: psr.rule_below_offset,
-            rule_below_left_indent: psr.rule_below_left_indent,
-            rule_below_right_indent: psr.rule_below_right_indent,
-            rule_below_width: psr.rule_below_width,
+            space_before: resolve_attr(style_lookup, psr, :space_before),
+            space_after: resolve_attr(style_lookup, psr, :space_after),
+            first_line_indent: resolve_attr(style_lookup, psr,
+                                            :first_line_indent),
+            left_indent: resolve_attr(style_lookup, psr, :left_indent),
+            right_indent: resolve_attr(style_lookup, psr, :right_indent),
+            auto_leading: resolve_attr(style_lookup, psr, :auto_leading),
+            drop_cap_lines: resolve_attr(style_lookup, psr, :drop_cap_lines),
+            drop_cap_characters: resolve_attr(style_lookup, psr,
+                                              :drop_cap_characters),
+            bullets_and_numbering_list_type: resolve_attr(
+              style_lookup, psr, :bullets_and_numbering_list_type
+            ),
+            bullet_character_value: resolve_attr(style_lookup, psr,
+                                                 :bullet_character_value),
+            bullets_text_after: resolve_attr(style_lookup, psr,
+                                             :bullets_text_after),
+            numbering_expression: resolve_attr(style_lookup, psr,
+                                               :numbering_expression),
+            rule_above: resolve_attr(style_lookup, psr, :rule_above),
+            rule_above_line_weight: resolve_attr(style_lookup, psr,
+                                                 :rule_above_line_weight),
+            rule_above_color: resolve_attr(style_lookup, psr, :stroke_color),
+            rule_above_tint: resolve_attr(style_lookup, psr,
+                                          :rule_above_tint),
+            rule_above_offset: resolve_attr(style_lookup, psr,
+                                            :rule_above_offset),
+            rule_above_left_indent: resolve_attr(style_lookup, psr,
+                                                 :rule_above_left_indent),
+            rule_above_right_indent: resolve_attr(style_lookup, psr,
+                                                  :rule_above_right_indent),
+            rule_above_width: resolve_attr(style_lookup, psr,
+                                           :rule_above_width),
+            rule_below: resolve_attr(style_lookup, psr, :rule_below),
+            rule_below_line_weight: resolve_attr(style_lookup, psr,
+                                                 :rule_below_line_weight),
+            rule_below_color: resolve_attr(style_lookup, psr, :stroke_color),
+            rule_below_tint: resolve_attr(style_lookup, psr,
+                                          :rule_below_tint),
+            rule_below_offset: resolve_attr(style_lookup, psr,
+                                            :rule_below_offset),
+            rule_below_left_indent: resolve_attr(style_lookup, psr,
+                                                 :rule_below_left_indent),
+            rule_below_right_indent: resolve_attr(style_lookup, psr,
+                                                  :rule_below_right_indent),
+            rule_below_width: resolve_attr(style_lookup, psr,
+                                           :rule_below_width),
           )
           prepend_list_marker(paragraph)
           paragraph
         end
       end
 
-      def self.csr_runs(psr, condition_filter: nil)
+      def self.csr_runs(psr, condition_filter: nil, style_lookup: nil)
         psr.character_style_range.filter_map do |csr|
           next unless condition_visible?(csr, condition_filter)
 
@@ -165,29 +186,54 @@ module Idml
 
           StyledRun.new(
             text: text,
-            font_style: csr.font_style,
-            point_size: csr.point_size || DEFAULT_POINT_SIZE,
-            fill_color: csr.fill_color,
-            fill_tint: csr.fill_tint,
-            applied_font: csr.applied_font,
+            font_style: resolve_csr(style_lookup, csr, :font_style),
+            point_size: resolve_csr(style_lookup, csr, :point_size) ||
+                        DEFAULT_POINT_SIZE,
+            fill_color: resolve_csr(style_lookup, csr, :fill_color),
+            fill_tint: resolve_csr(style_lookup, csr, :fill_tint),
+            applied_font: resolve_csr(style_lookup, csr, :applied_font),
             alignment: alignment_for(csr),
-            tracking: csr.tracking,
-            capitalization: csr.capitalization,
-            position: csr.position,
-            underline: csr.underline,
-            underline_offset: csr.underline_offset,
-            underline_weight: csr.underline_weight,
-            strike_thru: csr.strike_thru,
-            strike_through_offset: csr.strike_through_offset,
-            strike_through_weight: csr.strike_through_weight,
-            horizontal_scale: csr.horizontal_scale,
-            vertical_scale: csr.vertical_scale,
-            baseline_shift: csr.baseline_shift,
+            tracking: resolve_csr(style_lookup, csr, :tracking),
+            capitalization: resolve_csr(style_lookup, csr, :capitalization),
+            position: resolve_csr(style_lookup, csr, :position),
+            underline: resolve_csr(style_lookup, csr, :underline),
+            underline_offset: resolve_csr(style_lookup, csr,
+                                          :underline_offset),
+            underline_weight: resolve_csr(style_lookup, csr,
+                                          :underline_weight),
+            strike_thru: resolve_csr(style_lookup, csr, :strike_thru),
+            strike_through_offset: resolve_csr(style_lookup, csr,
+                                               :strike_through_offset),
+            strike_through_weight: resolve_csr(style_lookup, csr,
+                                               :strike_through_weight),
+            horizontal_scale: resolve_csr(style_lookup, csr,
+                                          :horizontal_scale),
+            vertical_scale: resolve_csr(style_lookup, csr, :vertical_scale),
+            baseline_shift: resolve_csr(style_lookup, csr, :baseline_shift),
           )
         end
       end
       private_class_method :csr_runs
 
+      # Resolves a paragraph-level attribute from PSR or its
+      # referenced ParagraphStyle. When style_lookup is nil,
+      # falls back to reading the PSR directly (backward compat).
+      def self.resolve_attr(style_lookup, psr, attr_name)
+        return psr.public_send(attr_name) unless style_lookup
+
+        style_lookup.resolve_para_attr(psr, attr_name)
+      end
+      private_class_method :resolve_attr
+
+      # Resolves a character-level attribute from CSR or its
+      # referenced CharacterStyle.
+      def self.resolve_csr(style_lookup, csr, attr_name)
+        return csr.public_send(attr_name) unless style_lookup
+
+        style_lookup.resolve_char_attr(csr, attr_name)
+      end
+      private_class_method :resolve_csr
+
       # 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).

data/lib/idml/render.rb

@@ -8,6 +8,7 @@ module Idml
     autoload :Image,               "#{__dir__}/render/image"
     autoload :ColorResolver,       "#{__dir__}/render/color_resolver"
     autoload :StyleResolver,       "#{__dir__}/render/style_resolver"
+    autoload :StyleLookup,         "#{__dir__}/render/style_lookup"
     autoload :FontReferenceResolver,
              "#{__dir__}/render/font_reference_resolver"
     autoload :GradientResolver,    "#{__dir__}/render/gradient_resolver"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.0
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-09 00:00:00.000000000 Z
+date: 2026-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -172,6 +172,7 @@ files:
 - TODO.pdf/113-multi-column-text-frames.md
 - TODO.pdf/114-text-wrap-around-shapes.md
 - TODO.pdf/115-bullet-numbered-lists.md
+- TODO.pdf/116-applied-style-resolution.md
 - TODO.pdf/12-idml-to-pdf-pipeline.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
@@ -280,6 +281,7 @@ files:
 - lib/idml/elements/character_style_group.rb
 - lib/idml/elements/character_style_range.rb
 - lib/idml/elements/color.rb
+- lib/idml/elements/column.rb
 - lib/idml/elements/condition.rb
 - lib/idml/elements/content.rb
 - lib/idml/elements/content_transparency_setting.rb
@@ -467,6 +469,7 @@ files:
 - lib/idml/render/stroke_style.rb
 - lib/idml/render/structure_mapper.rb
 - lib/idml/render/structure_tracker.rb
+- lib/idml/render/style_lookup.rb
 - lib/idml/render/style_resolver.rb
 - lib/idml/text_engine.rb
 - lib/idml/text_engine/cjk_layout.rb