ea 0.6.107 → 0.6.109

data/lib/ea/svg/ea_emitter/connector_redock.rb

@@ -53,10 +53,10 @@ module Ea
             return stored_top_pairs(connector, source_bounds, pairs)
           end
 
-          # EA docks these markers on the outer edge of the 2px box stroke.
-          outline = bounds.map do |box|
-            Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
-                                  width: box.width + 2, height: box.height + 2)
+          refs = [source_ref, target_ref]
+          duids = connector.style.to_h.values_at(:soid, :eoid)
+          outline = bounds.each_with_index.map do |box, index|
+            outline_bounds(box, diagram, refs[index], duids[index])
           end
           candidate = clipped_pairs(outline, anchors)
           candidate[0] = external_source_point(connector, outline.first, anchors, candidate.first)
@@ -231,19 +231,34 @@ module Ea
           return false unless bounds.all? { |box| box.width.positive? && box.height.positive? }
 
           ends = [[refs.first, style[:soid]], [refs.last, style[:eoid]]]
-          ends.all? { |ref, duid| border_two?(diagram, ref, duid) }
+          ends.all? { |ref, duid| border_width?(diagram, ref, duid, 2) }
         end
         private_class_method :bordered_outline?
 
         # Every placement of the element (the DUID-matched one when the
-        # connector names it) must declare a border width of 2.
-        def border_two?(diagram, ref, duid)
+        # connector names it) must declare the same border width.
+        def border_width?(diagram, ref, duid, width)
+          placed = end_placements(diagram, ref, duid)
+          placed.any? && placed.all? { |el| el.line_width == width || el.style.to_h[:lwth] == width.to_s }
+        end
+        private_class_method :border_width?
+
+        # Explicit zero-width borders keep that end on the geometric edge;
+        # absent or inherited widths retain the default outer-stroke docking.
+        def outline_bounds(box, diagram, ref, duid)
+          return box if border_width?(diagram, ref, duid, 0)
+
+          Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
+                                width: box.width + 2, height: box.height + 2)
+        end
+        private_class_method :outline_bounds
+
+        def end_placements(diagram, ref, duid)
           placed = Array(diagram&.elements).select { |el| el.model_element_ref == ref }
           named = placed.select { |el| duid && el.duid.to_s.casecmp?(duid.to_s) }
-          placed = named unless named.empty?
-          placed.any? && placed.all? { |el| el.line_width == 2 || el.style.to_h[:lwth] == "2" }
+          named.empty? ? placed : named
         end
-        private_class_method :border_two?
+        private_class_method :end_placements
 
         def outline_connector?(connector, bounds)
           return true if default_model_connector?(connector)
@@ -397,12 +412,13 @@ module Ea
         end
         private_class_method :explicit_horizontal_source_dock?
 
-        # A stored Association ray whose source port certifies the shared
-        # anchor row is one explicit horizontal line: EA seats neither end
-        # in a compartment row, unlike Generalization/Aggregation targets.
+        # The QEA producer certifies stored Association rays from their
+        # endpoint origins. Keep the clipped ray even when a diagonal end
+        # coincides with a header divider. Other callers need a certified
+        # horizontal port before bypassing compartment row seating.
         def explicit_association_ray?(pairs, connector)
           produced = connector.style.to_h[:stored_association_ray] == true
-          return true if produced && pairs.first[1] == pairs.last[1]
+          return true if produced
 
           certified_association_ray?(pairs, connector)
         end

data/lib/ea/svg/ea_emitter/element/attribute_line_builder.rb

@@ -48,6 +48,7 @@ module Ea
             parts << ": #{type_str}" unless type_str.empty?
             mult = multiplicity
             parts << " #{mult}" unless mult.empty?
+            parts << " {ordered}" if property.is_ordered
             parts << " = #{property.default_value}" if property.default_value && !property.default_value.to_s.empty?
             parts.join.rstrip
           end
@@ -100,20 +101,21 @@ module Ea
           def multiplicity
             lower = property.multiplicity_lower
             upper = property.multiplicity_upper
-            if lower == 1 && upper == 1
-              raw = property.multiplicity_lower_raw
-              # Literal text bounds EA displays verbatim ('elements:
-              # Character [size]' - stored bounds 'size'/'size' parse
-              # to the 1..1 default).
-              return "[#{raw}]" if raw && raw == property.multiplicity_upper_raw
-
-              return ""
-            end
+            return default_multiplicity if lower == 1 && upper == 1
             return "" if lower.nil? && upper.nil?
+            return "[#{lower}]" if lower == upper && upper != -1
 
             "[#{lower || 0}..#{bound_text(upper)}]"
           end
 
+          # Literal text bounds EA displays verbatim ('elements:
+          # Character [size]' - stored bounds 'size'/'size' parse
+          # to the 1..1 default).
+          def default_multiplicity
+            raw = property.multiplicity_lower_raw
+            raw && raw == property.multiplicity_upper_raw ? "[#{raw}]" : ""
+          end
+
           def bound_text(value)
             # EA renders a stored literal bound ("n") verbatim, and a
             # computed-unbounded upper as "*" (verified against

data/lib/ea/svg/ea_emitter/element/attribute_renderer.rb

@@ -47,12 +47,14 @@ module Ea
           end
 
           def self.render(lines, bounds:, first_y:, family:,
-                          size:, size_unit: DEFAULT_FONT_UNIT,
+                          size:, size_unit: DEFAULT_FONT_UNIT, logical_height: nil,
                           fill: "#000000",
                           visibility_x_offset: DEFAULT_VISIBILITY_X_OFFSET,
                           content_x_offset: nil)
 
-            line_h = size + ROW_LINE_OFFSET
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, offset: ROW_LINE_OFFSET, logical_height: logical_height
+            )
             offsets = group_lead_offsets(lines)
             text_blocks = []
             lines.each_with_index do |line, idx|
@@ -60,15 +62,27 @@ module Ea
               visibility, rest = split_visibility(line)
               if visibility
                 unless visibility.strip.empty?
-                  text_blocks << build_text(bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill)
+                  text_blocks << build_text(
+                    bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill,
+                    logical_height: logical_height
+                  )
                 end
                 offset = (content_x_offset || DEFAULT_CONTENT_X_OFFSET) +
                          2 * (size - 7)
-                text_blocks << build_text(bounds.x + offset, y, rest, family, size, size_unit, fill)
+                offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
+                text_blocks << build_text(
+                  bounds.x + offset, y, rest, family, size, size_unit, fill, logical_height: logical_height
+                )
               elsif line.strip.start_with?("«")
-                text_blocks << build_text(bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill)
+                text_blocks << build_text(
+                  bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill,
+                  logical_height: logical_height
+                )
               else
-                text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
+                text_blocks << build_text(
+                  bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill,
+                  logical_height: logical_height
+                )
               end
             end
             group_style = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#{fill};fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
@@ -149,9 +163,11 @@ module Ea
           end
           private_class_method :split_visibility
 
-          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT, fill = "#000000")
+          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT,
+                              fill = "#000000", logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size, size_unit: size_unit, fill: fill).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height, fill: fill).to_svg
           end
           private_class_method :build_text
 

data/lib/ea/svg/ea_emitter/element/compartment_geometry.rb

@@ -40,10 +40,14 @@ module Ea
                           attr_line_offset: 6,
                           attr_first_offset: 7,
                           attr_group_lead: 0,
+                         family: nil, size_unit: "pt", logical_height: nil,
                           header_ghost: false,
                           header_ghost_tight: false)
             @bounds = bounds
             @size = size
+            @family = family
+            @size_unit = size_unit
+            @logical_height = logical_height
             @header_lines_count = header_lines_count
             @attr_lines_count = attr_lines_count
             @op_lines_count = op_lines_count
@@ -61,6 +65,13 @@ module Ea
             @header_ghost_tight = header_ghost_tight
           end
 
+          def line_height(offset)
+            Ea::Fonts::Metrics.compartment_line_height(
+              size, family: @family, unit: @size_unit, offset: offset, logical_height: @logical_height
+            )
+          end
+          private :line_height
+
           def header_first_y
             bounds.y + size + (header_top_padding || 12)
           end
@@ -81,9 +92,9 @@ module Ea
             ghost_shift = header_ghost ? (header_ghost_tight ? 3 : 6) : 0
 
             header_first_y +
-              ([header_lines_count, 1].max - 1) * (size + (header_line_offset || 6)) +
+              ([header_lines_count, 1].max - 1) * line_height(header_line_offset || 6) +
               ghost_shift +
-              (marker_count.to_i * (size + 6)) +
+              (marker_count.to_i * line_height(6)) +
               (divider_offset || 8)
           end
 
@@ -104,13 +115,13 @@ module Ea
           def raw_attr_first_y
             return bounds.y + size + (header_top_padding || 12) + 12 unless divider_y
 
-            divider_y + size + (attr_first_offset || 7)
+            divider_y + line_height((attr_first_offset || 7) - 1) + 1
           end
 
           def attr_bottom_y
             return attr_first_y unless attr_lines_count&.positive?
 
-            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 6)) +
+            attr_first_y + (attr_lines_count - 1) * line_height(attr_line_offset || 6) +
               @attr_group_lead.to_i
           end
 
@@ -137,17 +148,16 @@ module Ea
           def op_bottom_y
             return op_divider_y unless op_lines_count&.positive?
 
-            op_first_y + (op_lines_count - 1) * (size + 6)
+            op_first_y + (op_lines_count - 1) * line_height(6)
           end
 
           # EA draws a single divider under the header and seats
-          # enumeration literals directly after it (+14 at 7pt),
-          # exactly like attribute rows - no second divider and no
-          # "literals" header. Verified against EA-published SVGs.
+          # the enumeration caption directly after it (+14 at 7pt),
+          # followed by the literal rows without a second divider.
           def enum_literal_first_y
             return nil unless divider_y
 
-            divider_y + size + (attr_first_offset || 7)
+            divider_y + line_height((attr_first_offset || 7) - 1) + 1
           end
 
           # OCL constraints follow the regular content with a divider and caption.
@@ -199,7 +209,7 @@ module Ea
           def enum_literals_bottom_y
             return nil unless enum_literal_first_y
 
-            enum_literal_first_y + ([enum_literals_count, 1].max - 1) * (size + 6)
+            enum_literal_first_y + ([enum_literals_count, 1].max - 1) * line_height(6)
           end
         end
       end

data/lib/ea/svg/ea_emitter/element/constraint_renderer.rb

@@ -39,27 +39,31 @@ module Ea
           def self.compartment_row(constraint, context, index)
             build_text(context.bounds.x + 5,
                        context.geometry.constraints_first_y + (index + 1) * (context.size + 5),
-                       "{#{constraint.name}}", context.family, context.size, context.text_fill)
+                       "{#{constraint.name}}", context.family, context.size, context.text_fill,
+                       size_unit: context.size_unit, logical_height: context.logical_height)
           end
           private_class_method :compartment_row
 
           def self.compartment_caption(context)
             TextRenderer.new(content: "constraints", x: caption_x(context),
                              y: context.geometry.constraints_first_y, family: context.family,
-                             size: context.size, fill: context.text_fill, style: "italic").to_svg
+                             size: context.size, size_unit: context.size_unit, logical_height: context.logical_height,
+                             fill: context.text_fill, style: "italic").to_svg
           end
           private_class_method :compartment_caption
 
           def self.caption_x(context)
             width = TextRenderer.estimate_width("constraints", context.size, nil,
-                                                family: context.family, style: "italic").round
+                                                family: context.family, style: "italic",
+                                                logical_height: context.logical_height).round
             context.bounds.x + ((context.bounds.width - width) / 2).floor
           end
           private_class_method :caption_x
 
-          def self.build_text(x, y, content, family, size, fill)
+          def self.build_text(x, y, content, family, size, fill, size_unit: "px", logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size, fill: fill).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height, fill: fill).to_svg
           end
           private_class_method :build_text
         end

data/lib/ea/svg/ea_emitter/element/enumeration_literal_renderer.rb

@@ -16,19 +16,22 @@ module Ea
           # EA lists literals alphabetically (case-insensitive) and
           # spaces rows at the same 13px pitch as attributes at 7pt
           # (size + 6) — corpus-verified against EA-published SVGs.
-          def self.render(literals, bounds:, first_y:, family:, size:)
-            line_h = size + 6
+          def self.render(literals, bounds:, first_y:, family:, size:, size_unit: "px", logical_height: nil)
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, logical_height: logical_height
+            )
             sorted = literals.sort_by { |l| [l.name.to_s.downcase, l.name.to_s] }
             text_blocks = sorted.each_with_index.map do |literal, idx|
               y = first_y + (idx * line_h)
-              build_text(bounds.x + 5, y, literal.name.to_s, family, size)
+              build_text(bounds.x + 5, y, literal.name.to_s, family, size, size_unit, logical_height: logical_height)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
-          def self.build_text(x, y, content, family, size)
+          def self.build_text(x, y, content, family, size, size_unit, logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height).to_svg
           end
           private_class_method :build_text
         end

data/lib/ea/svg/ea_emitter/element/header_line_pipeline.rb

@@ -19,7 +19,7 @@ module Ea
         module HeaderLinePipeline
           Context = Struct.new(:classifier, :diagram_package_id,
                                :visually_nested, :umldi_keyword,
-                               :bounds_width, :font_size, :family,
+                               :bounds_width, :font_size, :family, :logical_height,
                                :off_canvas_parent_name,
                                :foreign_package_name,
                                :suppress_stereotypes,
@@ -57,7 +57,8 @@ module Ea
             width = lambda do |s|
               TextRenderer.estimate_width(
                 s, context.font_size || 9, nil,
-                family: context.family, weight: "700", style: font_style
+                family: context.family, weight: "700", style: font_style,
+                logical_height: context.logical_height
               ).round
             end
             return [text] if context.bounds_width.nil?

data/lib/ea/svg/ea_emitter/element/header_line_provider/instance_spec.rb

@@ -20,15 +20,20 @@ module Ea
               return [] unless inst.is_a?(Ea::Model::InstanceSpecification)
 
               lines = stereotype_lines(inst, context)
-              label = inst.name.to_s
-              if inst.classifier_name && !inst.classifier_name.empty?
-                label = "#{label}: #{inst.classifier_name}"
-              end
-              lines + HeaderLinePipeline.wrap_words(label, context, :bold).map do |line|
+              lines + HeaderLinePipeline.wrap_words(label_for(inst), context, :bold).map do |line|
                 [line, :bold]
               end
             end
 
+            # "Name / alias: Classifier"; t_object.Alias is the instance role.
+            def self.label_for(inst)
+              label = inst.name.to_s
+              label = "#{label} / #{inst.role_name}" unless inst.role_name.to_s.empty?
+              return label if inst.classifier_name.to_s.empty?
+
+              "#{label}: #{inst.classifier_name}"
+            end
+
             def self.stereotype_lines(inst, context)
               return [] if context.suppress_stereotypes
 

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -11,12 +11,9 @@ module Ea
           # - Foreign elements (owning package ≠ the diagram's package,
           #   gated on t_diagram.ShowForeign) render the qualified
           #   name "OwningPackage::Name".
-          # - Qualified-name wrap: when the combined integer
-          #   textLength exceeds the element bounds width, EA splits
-          #   "pkg::Class" across two lines ("pkg::" then "Class"),
-          #   each centered independently. Corpus-verified: every
-          #   wrapped header overflows its box and every single-line
-          #   header fits (tightest observed slack 6px).
+          # - Qualified names wrap after their colon separator when
+          #   the measured name reaches the box width minus 6px.
+          #   Each resulting line retains its separator and is centered.
           #
           # InstanceSpecification returns [] (InstanceSpec provider
           # already emitted the full label).
@@ -42,9 +39,8 @@ module Ea
                 return [[name, weight]]
               end
 
-              if name.include?("::")
-                qualifier, base = name.split("::", 2)
-                [["#{qualifier}::", weight], [base, weight]]
+              if (qualified = name.match(/\A(.+?:{1,2})([^:\s].*)\z/))
+                [[qualified[1], weight], [qualified[2], weight]]
               else
                 HeaderLinePipeline.wrap_words(name, context, weight).map do |line|
                   [line, weight]
@@ -56,13 +52,13 @@ module Ea
               font_style = weight == :bold_italic ? "italic" : "normal"
               len = TextRenderer.estimate_width(
                 name, context.font_size || 9, nil,
-                family: context.family, weight: "700", style: font_style
+                family: context.family, weight: "700", style: font_style,
+                logical_height: context.logical_height
               ).round
-              # Same usable width as wrap_words: box width - 6.
-              # EA wraps "Content information::MD_FeatureCatalogue-
-              # Description" (parts 86 + 137 + space 4 = 227) inside
-              # a 230px box (F851A657).
-              len > context.bounds_width.to_i - 6
+              # Qualified classifier names also wrap at the exact boundary;
+              # ordinary word wrapping keeps the shared pipeline threshold.
+              usable = context.bounds_width.to_i - 6
+              name.match?(/:{1,2}[^:\s]/) ? len >= usable : len > usable
             end
 
             # EA renders the plain classifier name in element headers;

data/lib/ea/svg/ea_emitter/element/header_renderer.rb

@@ -12,17 +12,20 @@ module Ea
         # x= is the start position, not the center).
         class HeaderRenderer
           def self.render(lines, bounds:, first_y:, family:,
-                          size:, size_unit: "pt",
+                          size:, size_unit: "pt", logical_height: nil,
                           fill: "#000000", weight_normal: 400, weight_bold: 700,
                           stroke_in_text: "#000000", width_factor: 0.612,
                           line_offset: 6)
-            line_h = size + line_offset
+            logical_height = nil unless size_unit == "pt"
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, offset: line_offset, logical_height: logical_height
+            )
             text_blocks = lines.each_with_index.map do |(text, style), idx|
               weight = case style
                        when :bold, :bold_italic then weight_bold
                        else weight_normal
                        end
-              font_style = (style == :italic || style == :bold_italic) ? "italic" : "normal"
+              font_style = %i[italic italic_tight bold_italic].include?(style) ? "italic" : "normal"
               # EA spaces the line AFTER a right-aligned ghost 3px
               # wider than the pitch. Interfaces use a tighter +3
               # (936AA434/Surface: ghost 100, «interface» 116).
@@ -33,23 +36,22 @@ module Ea
                             end
               y = first_y + (idx * line_h) +
                   (idx >= 1 && ghost_shift.positive? ? ghost_shift : 0)
-              x = if style == :italic
-                    # EA right-aligns the off-canvas parent ghost at
-                    # the box's right edge by its integer textLength.
-                    bounds.x + bounds.width -
+              x = if %i[italic italic_tight].include?(style)
+                    # Parent ghosts end 3px inside the box's right edge.
+                    bounds.x + bounds.width - 3 -
                       Ea::Svg::EaEmitter::TextRenderer.estimate_width(
                         text, size, width_factor,
-                        family: family, weight: weight, style: font_style
+                        family: family, weight: weight, style: font_style, logical_height: logical_height
                       ).round
                   else
                     center_x_for(text, bounds, size, width_factor,
                                  family: family, weight: weight,
-                                 style: font_style)
+                                 style: font_style, logical_height: logical_height)
                   end
               TextRenderer.new(
                 content: text,
                 x: x, y: y,
-                family: family, size: size, size_unit: size_unit,
+                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
                 weight: weight, style: font_style, fill: fill,
                 stroke_in_text: stroke_in_text, width_factor: width_factor
               ).to_svg
@@ -60,9 +62,9 @@ module Ea
           # EA centers text by its INTEGER textLength and floors the
           # resulting x (verified exact against EA-published SVGs).
           def self.center_x_for(text, bounds, size, width_factor,
-                                family: nil, weight: nil, style: nil)
+                                family: nil, weight: nil, style: nil, logical_height: nil)
             len = Ea::Svg::EaEmitter::TextRenderer.estimate_width(
-              text, size, width_factor, family: family, weight: weight, style: style
+              text, size, width_factor, family: family, weight: weight, style: style, logical_height: logical_height
             ).round
             (bounds.x + (bounds.width - len) / 2.0).floor
           end

data/lib/ea/svg/ea_emitter/element/operation_renderer.rb

@@ -16,10 +16,13 @@ module Ea
           VISIBILITY_X_OFFSET = 5
           CONTENT_X_OFFSET = 22
 
-          def self.render(operations, bounds:, first_y:, family:, size:)
+          def self.render(operations, bounds:, first_y:, family:, size:, size_unit: "px",
+                          logical_height: nil, parameter_detail: nil)
             # EA's op rows pitch 13 (size + 6), same as attribute
             # rows (6D4C665D: ops 541..658 step 13).
-            line_h = size + 6
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              size, family: family, unit: size_unit, logical_height: logical_height
+            )
             text_blocks = []
             has_receptions = operations.any?(&:is_reception)
             if has_receptions
@@ -27,7 +30,7 @@ module Ea
                 content: "receptions",
                 x: bounds.x + (bounds.width / 2.0) - (8 * size * 0.65) / 2,
                 y: first_y,
-                family: family, size: size,
+                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
                 style: "italic", fill: "#000000"
               ).to_svg
             end
@@ -36,15 +39,16 @@ module Ea
             ops.each_with_index do |op, idx|
               y = first_y + ((idx + offset) * line_h)
               text_blocks << build_text(bounds.x + VISIBILITY_X_OFFSET, y,
-                                         visibility_prefix(op), family, size)
+                                        visibility_prefix(op), family, size, size_unit, logical_height: logical_height)
+              text = operation_text(op, parameter_detail: parameter_detail)
               text_blocks << build_text(bounds.x + AttributeRenderer.content_x_offset(size), y,
-                                         operation_text(op), family, size)
+                                        text, family, size, size_unit, logical_height: logical_height)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
           # Builds display lines for a classifier's operations.
-          def self.lines_for(classifier)
+          def self.lines_for(classifier, parameter_detail: nil)
             ops = classifier.operations
             return [] unless ops&.any?
 
@@ -52,7 +56,7 @@ module Ea
               visibility = visibility_prefix(op).strip
               params = (op.parameters || []).map do |p|
                 type = namespace_double_colon(p.type_name)
-                p.direction == "inout" ? "#{type}*" : "#{p.name}: #{type}"
+                parameter_text(p, type, parameter_detail)
               end.join(", ")
               return_type = namespace_double_colon(op.return_type_name)
               "#{visibility} #{op.name}(#{params}): #{return_type}".strip
@@ -64,9 +68,9 @@ module Ea
           end
           private_class_method :visibility_prefix
 
-          def self.operation_text(operation)
+          def self.operation_text(operation, parameter_detail: nil)
             prefix = operation.is_reception ? "«signal» " : ""
-            text = "#{prefix}#{operation.name}(#{reception_params(operation)})"
+            text = "#{prefix}#{operation.name}(#{reception_params(operation, parameter_detail)})"
             return text unless operation.return_type_name && !operation.is_reception
 
             "#{text}: #{operation.return_type_name}"
@@ -80,19 +84,28 @@ module Ea
           end
           private_class_method :namespace_double_colon
 
-          def self.reception_params(operation)
+          def self.parameter_text(param, type, parameter_detail)
+            return "#{type}*" if param.direction == "inout"
+            return type if parameter_detail == :type_only
+
+            "#{param.name}: #{type}"
+          end
+          private_class_method :parameter_text
+
+          def self.reception_params(operation, parameter_detail)
             params = (operation.parameters || []).filter_map { |p|
               next nil if p.type_name.to_s.empty?
 
-              p.direction == "inout" ? "#{p.type_name}*" : "#{p.name}: #{p.type_name}"
+              parameter_text(p, p.type_name, parameter_detail)
             }.join(", ")
             params
           end
           private_class_method :reception_params
 
-          def self.build_text(x, y, content, family, size)
+          def self.build_text(x, y, content, family, size, size_unit, logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size).to_svg
+                             family: family, size: size, size_unit: size_unit,
+                             logical_height: logical_height).to_svg
           end
           private_class_method :build_text
         end