xlsxrb 0.1.16 → 0.1.17

data/lib/xlsxrb/ooxml/worksheet_writer.rb

@@ -54,6 +54,8 @@ module Xlsxrb
         return if @started
 
         @started = true
+        @sheet_properties = sheet_properties
+        @sheet_format = sheet_format
         @builder.declaration
         @builder.open_tag("worksheet", { xmlns: SSML_NS, "xmlns:r": DOC_REL_NS })
 
@@ -130,10 +132,15 @@ module Xlsxrb
             cell_type_val = nil
           end
 
+          cell_style_id = resolve_style_id(cell_style_id, nil)
           col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
-          style_id = cell_style_id || attrs[:style_index] || col_style
+          col_style = resolve_style_id(col_style, nil)
+          row_style = resolve_style_id(attrs[:style_index], nil)
+          style_id = cell_style_id.nil? ? (row_style || col_style) : cell_style_id
           style_id = nil unless style_id.is_a?(Integer)
 
+          raise ArgumentError, "Non-finite Float #{value} is not supported in XLSX" if value.is_a?(Float) && !value.finite?
+
           # Fast path for common unstyled cells
           if !formula && !style_id && !cell_type_val
             case value
@@ -204,6 +211,8 @@ module Xlsxrb
             formula_expr = formula_expr[1..] if formula_expr.is_a?(String) && formula_expr.start_with?("=")
           end
 
+          raise ArgumentError, "Non-finite Float #{xml_val} is not supported in XLSX" if xml_val.is_a?(Float) && !xml_val.finite?
+
           if formula_expr
             case xml_val
             when true
@@ -257,43 +266,11 @@ module Xlsxrb
 
           if type == "inlineStr"
             if xml_val.is_a?(Xlsxrb::Elements::RichText)
-              buf << "><is>"
-              xml_val.runs.each do |run|
-                font = run[:font]
-                if font && !font.empty?
-                  buf << "<r><rPr>"
-                  buf << "<b/>" if font[:bold]
-                  buf << "<i/>" if font[:italic]
-                  buf << "<strike/>" if font[:strike]
-                  if font[:underline]
-                    if font[:underline] == true
-                      buf << "<u/>"
-                    else
-                      buf << '<u val="' << font[:underline].to_s << '"/>'
-                    end
-                  end
-                  buf << '<vertAlign val="' << font[:vert_align].to_s << '"/>' if font[:vert_align]
-                  buf << '<sz val="' << font[:sz].to_s << '"/>' if font[:sz]
-                  if font[:color]
-                    buf << '<color rgb="' << font[:color].to_s << '"/>'
-                  elsif font[:theme]
-                    tint_attr = font[:tint] ? " tint=\"#{font[:tint]}\"" : ""
-                    buf << '<color theme="' << font[:theme].to_s << '"' << tint_attr << "/>"
-                  end
-                  buf << '<rFont val="' << escape_xml(font[:name]) << '"/>' if font[:name]
-                  buf << '<family val="' << font[:family].to_s << '"/>' if font[:family]
-                  buf << '<scheme val="' << font[:scheme].to_s << '"/>' if font[:scheme]
-                  buf << "</rPr><t>"
-                else
-                  buf << "<r><t>"
-                end
-                buf << escape_xml(run[:text]) << "</t></r>"
-              end
-              buf << "</is></c>"
+              write_inline_rich_text(buf, xml_val)
             else
               buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
             end
-          elsif formula_expr
+          elsif formula_expr || (formula_type && formula_type.to_sym == :shared && !formula_si.nil?)
             f_attrs = +""
             if formula_type
               case formula_type.to_sym
@@ -307,7 +284,11 @@ module Xlsxrb
               end
             end
             f_attrs << ' ca="1"' if formula_ca
-            buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            if formula_expr && !formula_expr.empty?
+              buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            else
+              buf << "><f#{f_attrs}/>"
+            end
             if xml_val.nil?
               buf << "<v>0</v></c>"
             else
@@ -356,6 +337,8 @@ module Xlsxrb
               val_str = value >= 0 && value < 65_536 ? INTEGER_STRINGS[value] : value.to_s
               buf << '<c r="' << col_ref << row_num_str << '"><v>' << val_str << "</v></c>"
             when Float
+              raise ArgumentError, "Non-finite Float #{value} is not supported in XLSX" unless value.finite?
+
               buf << '<c r="' << col_ref << row_num_str << '"><v>' << value.to_s << "</v></c>"
             when String
               raise ArgumentError, "Cell text length #{value.length} exceeds Excel limit of 32,767 characters" if @strict_excel_mode && value.length > 32_767
@@ -389,6 +372,8 @@ module Xlsxrb
                        "<c r=\"#{col_ref}#{row_num_str}\"><v>#{Xlsxrb::Ooxml::Utils.datetime_to_serial(value, date1904: @date1904)}</v></c>"
                      end
             when Xlsxrb::Elements::Formula
+              raise ArgumentError, "Non-finite Float #{value.cached_value} is not supported in XLSX" if value.cached_value.is_a?(Float) && !value.cached_value.finite?
+
               formula_expr = value.expression
               formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
               f_attrs = +""
@@ -420,20 +405,27 @@ module Xlsxrb
               else
                 v_val = value.cached_value.is_a?(String) ? escape_xml(value.cached_value) : value.cached_value
               end
-              buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{v_val}</v></c>"
+              f_tag = if formula_expr && !formula_expr.empty?
+                        "<f#{f_attrs}>#{escape_xml(formula_expr)}</f>"
+                      else
+                        "<f#{f_attrs}/>"
+                      end
+              buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}>#{f_tag}<v>#{v_val}</v></c>"
             when Hash
-              if value.key?(:formula)
+              if value.key?(:formula) || value.key?(:expression) || (value[:type]&.to_sym == :shared && (value.key?(:shared_index) || value.key?(:si)))
                 formula_expr = value[:formula] || value[:expression]
-                formula_expr = formula_expr[1..] if formula_expr.start_with?("=")
+                formula_expr = formula_expr[1..] if formula_expr.is_a?(String) && formula_expr.start_with?("=")
                 f_attrs = +""
-                if value[:type]
-                  case value[:type].to_sym
+                f_type = value[:type] || (:shared if value.key?(:shared_index) || value.key?(:si))
+                if f_type
+                  case f_type.to_sym
                   when :array
                     f_attrs << ' t="array"'
                     f_attrs << %( ref="#{value[:ref]}") if value[:ref]
                   when :shared
                     f_attrs << ' t="shared"'
-                    f_attrs << %( si="#{value[:si] || value[:shared_index]}") if value[:si] || value[:shared_index]
+                    si = value[:si] || value[:shared_index]
+                    f_attrs << %( si="#{si}") if si
                     f_attrs << %( ref="#{value[:ref]}") if value[:ref]
                   end
                 end
@@ -445,6 +437,8 @@ module Xlsxrb
                           else
                             0
                           end
+                raise ArgumentError, "Non-finite Float #{xml_val} is not supported in XLSX" if xml_val.is_a?(Float) && !xml_val.finite?
+
                 c_type = ""
                 case xml_val
                 when true
@@ -458,19 +452,31 @@ module Xlsxrb
                   xml_val = xml_val.code
                 end
                 xml_val = escape_xml(xml_val) if xml_val.is_a?(String)
-                buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}><f#{f_attrs}>#{escape_xml(formula_expr)}</f><v>#{xml_val}</v></c>"
+                f_tag = if formula_expr && !formula_expr.empty?
+                          "<f#{f_attrs}>#{escape_xml(formula_expr)}</f>"
+                        else
+                          "<f#{f_attrs}/>"
+                        end
+                buf << "<c r=\"#{col_ref}#{row_num_str}\"#{c_type}>#{f_tag}<v>#{xml_val}</v></c>"
               end
             when Xlsxrb::Elements::CellError
               buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"e\"><v>#{value.code}</v></c>"
             when BigDecimal
               buf << "<c r=\"#{col_ref}#{row_num_str}\"><v>#{value.to_s("F")}</v></c>"
             else
-              idx = (sst_index[value] ||= begin
-                sst << value
-                sst.size - 1
-              end)
-              idx_str = idx < 65_536 ? INTEGER_STRINGS[idx] : idx.to_s
-              buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"s\"><v>#{idx_str}</v></c>"
+              if sst_index
+                idx = (sst_index[value] ||= begin
+                  sst << value
+                  sst.size - 1
+                end)
+                idx_str = idx < 65_536 ? INTEGER_STRINGS[idx] : idx.to_s
+                buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"s\"><v>#{idx_str}</v></c>"
+              elsif value.is_a?(Xlsxrb::Elements::RichText)
+                buf << '<c r="' << col_ref << row_num_str << '" t="inlineStr"'
+                write_inline_rich_text(buf, value)
+              else
+                buf << "<c r=\"#{col_ref}#{row_num_str}\" t=\"inlineStr\"><is><t>#{escape_xml(value.to_s)}</t></is></c>"
+              end
             end
           end
 
@@ -537,6 +543,8 @@ module Xlsxrb
             next
           end
 
+          raise ArgumentError, "Non-finite Float #{value} is not supported in XLSX" if value.is_a?(Float) && !value.finite?
+
           # Fast path: unstyled numbers, booleans, and simple strings (majority of cells)
           if style_id.nil? && !value.is_a?(Xlsxrb::Elements::Formula) && !value.is_a?(Hash)
             case value
@@ -670,12 +678,14 @@ module Xlsxrb
             type = "e"
           end
 
+          raise ArgumentError, "Non-finite Float #{xml_val} is not supported in XLSX" if xml_val.is_a?(Float) && !xml_val.finite?
+
           formula_expr = formula_expr[1..] if formula_expr&.start_with?("=")
 
           buf << '<c r="' << col_ref << row_num_str << '"'
           buf << ' s="' << style_id.to_s << '"' if style_id
           buf << ' t="' << type << '"' if type
-          if formula_expr
+          if formula_expr || (formula_type && formula_type.to_sym == :shared && !formula_si.nil?)
             f_attrs = +""
             if formula_type
               case formula_type.to_sym
@@ -689,7 +699,11 @@ module Xlsxrb
               end
             end
             f_attrs << ' ca="1"' if formula_ca
-            buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            if formula_expr && !formula_expr.empty?
+              buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            else
+              buf << "><f#{f_attrs}/>"
+            end
             if xml_val.nil?
               buf << "<v>0</v></c>"
             else
@@ -698,7 +712,11 @@ module Xlsxrb
               buf << "<v>" << v_str << "</v></c>"
             end
           elsif type == "inlineStr"
-            buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
+            if xml_val.is_a?(Xlsxrb::Elements::RichText)
+              write_inline_rich_text(buf, xml_val)
+            else
+              buf << "><is><t>" << escape_xml(xml_val.to_s) << "</t></is></c>"
+            end
           else
             buf << "><v>" << xml_val.to_s << "</v></c>"
           end
@@ -715,13 +733,13 @@ module Xlsxrb
 
       # Write the worksheet footer. Call once after all rows.
       # Options for post-sheetData elements (in OOXML order):
-      def finish(drawing_rid: nil, sheet_protection: nil, protected_ranges: nil, auto_filter: nil,
+      def finish(drawing_rid: nil, picture_rid: nil, sheet_protection: nil, protected_ranges: nil, auto_filter: nil,
                  filter_columns: nil, sort_state: nil, merge_cells: nil,
                  conditional_formats: nil, data_validations: nil,
                  hyperlinks: nil, print_options: nil, page_margins: nil,
                  page_setup: nil, header_footer: nil, row_breaks: nil,
-                 col_breaks: nil, cell_watches: nil, tables: nil, table_start_rid: nil,
-                 legacy_drawing_rid: nil, sparkline_groups: nil)
+                 col_breaks: nil, cell_watches: nil, ignored_errors: nil, tables: nil, table_start_rid: nil,
+                 legacy_drawing_rid: nil, sparkline_groups: nil, phonetic_pr: nil, sheet_calc_pr: nil)
         return if @finished
 
         start unless @started
@@ -733,10 +751,13 @@ module Xlsxrb
         @builder.close_tag("sheetData")
 
         # Elements must appear in OOXML specification order after sheetData
+        calc_pr = sheet_calc_pr || (@sheet_properties if @sheet_properties && !@sheet_properties[:full_calc_on_load].nil?)
+        write_sheet_calc_pr(calc_pr) if calc_pr
         write_sheet_protection(sheet_protection) if sheet_protection
         write_protected_ranges(protected_ranges) if protected_ranges && !protected_ranges.empty?
         write_auto_filter(auto_filter, filter_columns, sort_state) if auto_filter
         write_merge_cells(merge_cells) if merge_cells && !merge_cells.empty?
+        write_phonetic_pr(phonetic_pr) if phonetic_pr
         write_conditional_formatting(conditional_formats) if conditional_formats && !conditional_formats.empty?
         write_data_validations(data_validations) if data_validations && !data_validations.empty?
         write_hyperlinks(hyperlinks) if hyperlinks && !hyperlinks.empty?
@@ -747,8 +768,10 @@ module Xlsxrb
         write_row_breaks(row_breaks) if row_breaks && !row_breaks.empty?
         write_col_breaks(col_breaks) if col_breaks && !col_breaks.empty?
         write_cell_watches(cell_watches) if cell_watches && !cell_watches.empty?
+        write_ignored_errors(ignored_errors) if ignored_errors && !ignored_errors.empty?
         @builder.empty_tag("drawing", { "r:id": drawing_rid }) if drawing_rid
         @builder.empty_tag("legacyDrawing", { "r:id": legacy_drawing_rid }) if legacy_drawing_rid
+        @builder.empty_tag("picture", { "r:id": picture_rid }) if picture_rid
         write_table_parts(tables, table_start_rid) if tables && !tables.empty?
         write_sparklines(sparkline_groups) if sparkline_groups && !sparkline_groups.empty?
         @builder.close_tag("worksheet")
@@ -764,6 +787,8 @@ module Xlsxrb
           return mapped if mapped
         end
 
+        return 0 if [:default, :none, "default", "none"].include?(style)
+
         style.is_a?(Integer) ? style : nil
       end
 
@@ -771,15 +796,29 @@ module Xlsxrb
 
       def write_sheet_properties(props)
         attrs = {}
-        has_children = props[:tab_color] || !props[:fit_to_page].nil? || !props[:outline_below].nil? || !props[:outline_right].nil?
+        attrs[:codeName] = props[:code_name].to_s if props[:code_name]
+        tc_attrs = build_tab_color_attrs(props)
+
+        outline_props = props[:outline_properties] || props[:outline_pr] || props
+        apply_styles = props.fetch(:apply_styles, outline_props[:apply_styles])
+        summary_below = props.fetch(:summary_below, props.fetch(:outline_below, outline_props[:summary_below]))
+        summary_right = props.fetch(:summary_right, props.fetch(:outline_right, outline_props[:summary_right]))
+        show_outline_symbols = props.fetch(:show_outline_symbols, props.fetch(:show_symbols, outline_props[:show_outline_symbols]))
+        has_outline = !apply_styles.nil? || !summary_below.nil? || !summary_right.nil? || !show_outline_symbols.nil?
+
+        has_children = tc_attrs || !props[:fit_to_page].nil? || has_outline
         if has_children
           @builder.open_tag("sheetPr", attrs)
-          @builder.empty_tag("tabColor", { rgb: props[:tab_color] }) if props[:tab_color]
-
-          outline_attrs = {}
-          outline_attrs[:summaryBelow] = props[:outline_below] ? "1" : "0" unless props[:outline_below].nil?
-          outline_attrs[:summaryRight] = props[:outline_right] ? "1" : "0" unless props[:outline_right].nil?
-          @builder.empty_tag("outlinePr", outline_attrs) unless outline_attrs.empty?
+          @builder.empty_tag("tabColor", tc_attrs) if tc_attrs
+
+          if has_outline
+            outline_attrs = {}
+            outline_attrs[:applyStyles] = apply_styles ? "1" : "0" unless apply_styles.nil?
+            outline_attrs[:summaryBelow] = summary_below ? "1" : "0" unless summary_below.nil?
+            outline_attrs[:summaryRight] = summary_right ? "1" : "0" unless summary_right.nil?
+            outline_attrs[:showOutlineSymbols] = show_outline_symbols ? "1" : "0" unless show_outline_symbols.nil?
+            @builder.empty_tag("outlinePr", outline_attrs) unless outline_attrs.empty?
+          end
 
           unless props[:fit_to_page].nil?
             @builder.empty_tag("pageSetUpPr", { fitToPage: props[:fit_to_page] ? "1" : "0" })
@@ -791,6 +830,29 @@ module Xlsxrb
         end
       end
 
+      def build_tab_color_attrs(props)
+        tc = props[:tab_color]
+        if tc.is_a?(Hash)
+          attrs = {}
+          attrs[:auto] = "1" if tc[:auto]
+          attrs[:indexed] = tc[:indexed].to_s if tc[:indexed]
+          attrs[:rgb] = tc[:rgb].to_s.delete_prefix("#") if tc[:rgb]
+          attrs[:theme] = tc[:theme].to_s if tc[:theme]
+          attrs[:tint] = tc[:tint].to_s if tc[:tint]
+          attrs.empty? ? nil : attrs
+        elsif tc.is_a?(String) || tc.is_a?(Symbol)
+          { rgb: tc.to_s.delete_prefix("#") }
+        elsif props[:tab_color_theme]
+          attrs = { theme: props[:tab_color_theme].to_s }
+          attrs[:tint] = props[:tab_color_tint].to_s if props[:tab_color_tint]
+          attrs
+        elsif props[:tab_color_indexed]
+          { indexed: props[:tab_color_indexed].to_s }
+        elsif props[:tab_color_auto]
+          { auto: "1" }
+        end
+      end
+
       def write_sheet_views(freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
         @builder.open_tag("sheetViews")
         sv_attrs = { workbookViewId: "0" }
@@ -1009,7 +1071,7 @@ module Xlsxrb
               snake = t_str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
                            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
                            .downcase.to_sym
-              type = snake if %i[cell_is expression color_scale data_bar icon_set above_average top10 duplicate_values unique_values contains_text not_contains_text begins_with ends_with contains_blanks not_contains_blanks time_period].include?(snake)
+              type = snake if %i[cell_is expression color_scale data_bar icon_set above_average top10 duplicate_values unique_values contains_text not_contains_text begins_with ends_with contains_blanks not_contains_blanks contains_errors not_contains_errors time_period].include?(snake)
             end
 
             cf_type = case type
@@ -1028,12 +1090,17 @@ module Xlsxrb
                       when :ends_with then "endsWith"
                       when :contains_blanks then "containsBlanks"
                       when :not_contains_blanks then "notContainsBlanks"
+                      when :contains_errors then "containsErrors"
+                      when :not_contains_errors then "notContainsErrors"
                       when :time_period then "timePeriod"
                       else type.to_s
                       end
 
             r_attrs = { type: cf_type, priority: (rule[:priority] || (idx + 1)).to_s }
-            r_attrs[:operator] = rule[:operator].to_s if rule[:operator]
+            if rule[:operator]
+              op = rule[:operator]
+              r_attrs[:operator] = DslHelpers::CF_OPERATORS[op.to_sym] || op.to_s
+            end
             r_attrs[:dxfId] = rule[:format_id].to_s if rule[:format_id]
             r_attrs[:stopIfTrue] = "1" if rule[:stop_if_true]
             r_attrs[:aboveAverage] = "0" if rule[:above_average] == false
@@ -1042,23 +1109,22 @@ module Xlsxrb
             r_attrs[:percent] = "1" if rule[:percent]
             r_attrs[:bottom] = "1" if rule[:bottom]
             r_attrs[:text] = rule[:text].to_s if rule[:text]
-            r_attrs[:timePeriod] = rule[:time_period].to_s if rule[:time_period]
+            if rule[:time_period]
+              tp = rule[:time_period]
+              r_attrs[:timePeriod] = DslHelpers::CF_TIME_PERIODS[tp.to_sym] || tp.to_s
+            end
             r_attrs[:stdDev] = rule[:std_dev].to_s if rule[:std_dev]
 
             case type
             when :color_scale
               @builder.open_tag("cfRule", r_attrs)
               cs = rule[:color_scale] || {}
-              cfvos = cs[:cfvo] || [
-                { type: "min" },
-                { type: "percent", val: "50" },
-                { type: "max" }
-              ]
               colors = cs[:colors] || [
                 "FFF8696B", # Red
                 "FFFFEB84", # Yellow
                 "FF63BE7B"  # Green
               ]
+              cfvos = cs[:cfvo] || (colors.size == 2 ? [{ type: "min" }, { type: "max" }] : [{ type: "min" }, { type: "percent", val: "50" }, { type: "max" }])
               @builder.tag("colorScale") do |b|
                 cfvos.each do |cfvo|
                   cfvo_attrs = { type: cfvo[:type] }
@@ -1115,11 +1181,28 @@ module Xlsxrb
               @builder.open_tag("cfRule", r_attrs)
               is = rule[:icon_set] || {}
               icon_style = is[:icon_set] || rule[:icon_style] || "3Arrows"
-              cfvos = is[:cfvo] || [
-                { type: "percent", val: "0" },
-                { type: "percent", val: "33" },
-                { type: "percent", val: "67" }
-              ]
+              cfvos = is[:cfvo] || if icon_style.to_s.start_with?("4")
+                                     [
+                                       { type: "percent", val: "0" },
+                                       { type: "percent", val: "25" },
+                                       { type: "percent", val: "50" },
+                                       { type: "percent", val: "75" }
+                                     ]
+                                   elsif icon_style.to_s.start_with?("5")
+                                     [
+                                       { type: "percent", val: "0" },
+                                       { type: "percent", val: "20" },
+                                       { type: "percent", val: "40" },
+                                       { type: "percent", val: "60" },
+                                       { type: "percent", val: "80" }
+                                     ]
+                                   else
+                                     [
+                                       { type: "percent", val: "0" },
+                                       { type: "percent", val: "33" },
+                                       { type: "percent", val: "67" }
+                                     ]
+                                   end
               is_attrs = { iconSet: icon_style }
               is_attrs[:reverse] = is[:reverse] ? "1" : "0" unless is[:reverse].nil?
               is_attrs[:percent] = is[:percent] ? "1" : "0" unless is[:percent].nil?
@@ -1167,13 +1250,25 @@ module Xlsxrb
           dv_attrs[:type] = dv_type.to_s if dv_type
           dv_attrs[:operator] = dv[:operator].to_s if dv[:operator]
           dv_attrs[:allowBlank] = "1" if dv[:allow_blank]
-          dv_attrs[:showInputMessage] = "1" if dv[:show_input_message]
-          dv_attrs[:showErrorMessage] = "1" if dv[:show_error_message]
+          show_input = if dv.key?(:show_input_message)
+                         dv[:show_input_message]
+                       else
+                         !dv[:prompt].nil? || !dv[:prompt_title].nil?
+                       end
+          dv_attrs[:showInputMessage] = "1" if show_input
+
+          show_error = if dv.key?(:show_error_message)
+                         dv[:show_error_message]
+                       else
+                         !dv[:error].nil? || !dv[:error_title].nil?
+                       end
+          dv_attrs[:showErrorMessage] = "1" if show_error
+
           dv_attrs[:errorStyle] = dv[:error_style].to_s if dv[:error_style]
-          dv_attrs[:errorTitle] = dv[:error_title] if dv[:error_title]
-          dv_attrs[:error] = dv[:error] if dv[:error]
-          dv_attrs[:promptTitle] = dv[:prompt_title] if dv[:prompt_title]
-          dv_attrs[:prompt] = dv[:prompt] if dv[:prompt]
+          dv_attrs[:errorTitle] = dv[:error_title].to_s.gsub(/\r\n|\r|\n/, "_x000a_") if dv[:error_title]
+          dv_attrs[:error] = dv[:error].to_s.gsub(/\r\n|\r|\n/, "_x000a_") if dv[:error]
+          dv_attrs[:promptTitle] = dv[:prompt_title].to_s.gsub(/\r\n|\r|\n/, "_x000a_") if dv[:prompt_title]
+          dv_attrs[:prompt] = dv[:prompt].to_s.gsub(/\r\n|\r|\n/, "_x000a_") if dv[:prompt]
           dv_attrs[:showDropDown] = "1" if dv[:show_drop_down]
           dv_attrs[:imeMode] = dv[:ime_mode].to_s if dv[:ime_mode]
 
@@ -1286,6 +1381,41 @@ module Xlsxrb
         @builder.close_tag("cellWatches")
       end
 
+      def write_ignored_errors(errors)
+        @builder.open_tag("ignoredErrors")
+        errors.each do |ie|
+          attrs = { sqref: ie[:sqref].to_s }
+          attrs[:evalError] = "1" if ie[:eval_error]
+          attrs[:twoDigitTextYear] = "1" if ie[:two_digit_text_year]
+          attrs[:numberStoredAsText] = "1" if ie[:number_stored_as_text]
+          attrs[:formula] = "1" if ie[:formula]
+          attrs[:formulaRange] = "1" if ie[:formula_range]
+          attrs[:unlockedFormula] = "1" if ie[:unlocked_formula]
+          attrs[:emptyCellReference] = "1" if ie[:empty_cell_reference]
+          attrs[:listDataValidation] = "1" if ie[:list_data_validation]
+          attrs[:calculatedColumn] = "1" if ie[:calculated_column]
+          @builder.empty_tag("ignoredError", attrs)
+        end
+        @builder.close_tag("ignoredErrors")
+      end
+
+      def write_phonetic_pr(props)
+        attrs = { fontId: (props[:font_id] || props["font_id"] || 0).to_s }
+        type = props[:type] || props["type"]
+        attrs[:type] = type.to_s if type
+        align = props[:alignment] || props["alignment"]
+        attrs[:alignment] = align.to_s if align
+        @builder.empty_tag("phoneticPr", attrs)
+      end
+
+      def write_sheet_calc_pr(props)
+        return unless props
+
+        attrs = {}
+        attrs[:fullCalcOnLoad] = props[:full_calc_on_load] ? "1" : "0" unless props[:full_calc_on_load].nil?
+        @builder.empty_tag("sheetCalcPr", attrs) unless attrs.empty?
+      end
+
       def write_table_parts(tables, start_rid)
         @builder.open_tag("tableParts", { count: tables.size.to_s })
         tables.each_with_index do |_tbl, idx|
@@ -1367,24 +1497,27 @@ module Xlsxrb
       # --- Columns ---
 
       def write_columns(columns)
+        default_width = @sheet_format ? (@sheet_format[:default_col_width] || @sheet_format["default_col_width"]) : nil
         @builder.open_tag("cols")
         columns.each do |col|
           if col.is_a?(Elements::Column)
             min = col.unmapped_data[:min] || (col.index + 1)
             max = col.unmapped_data[:max] || (col.index + 1)
-            width = col.width
+            style_id = col.style_index
+            width = col.width || (style_id ? default_width : nil)
             hidden = col.hidden
-            custom_width = col.custom_width || col.width
+            custom_width = col.custom_width || !width.nil?
             outline_level = col.outline_level
-            style_id = col.style_index
+            collapsed = col.unmapped_data[:collapsed]
           else
             min = col[:min] || ((col[:index] || 0) + 1)
             max = col[:max] || ((col[:index] || 0) + 1)
-            width = col[:width]
+            style_id = col[:style_index] || col[:style]
+            width = col[:width] || (style_id ? default_width : nil)
             hidden = col[:hidden]
-            custom_width = col[:custom_width] || col[:width]
+            custom_width = col[:custom_width] || !width.nil?
             outline_level = col[:outline_level]
-            style_id = col[:style_index] || col[:style]
+            collapsed = col[:collapsed]
           end
           attrs = {
             min: min.to_s,
@@ -1392,8 +1525,9 @@ module Xlsxrb
           }
           attrs[:width] = width.to_s if width
           attrs[:hidden] = "1" if hidden
-          attrs[:customWidth] = "1" if custom_width
+          attrs[:customWidth] = "1" if custom_width && width
           attrs[:outlineLevel] = outline_level.to_s if outline_level
+          attrs[:collapsed] = "1" if collapsed
           attrs[:style] = style_id.to_s if style_id.is_a?(Integer)
           @builder.empty_tag("col", attrs)
         end
@@ -1491,6 +1625,73 @@ module Xlsxrb
         Xlsxrb::Elements::Cell.column_letter(index)
       end
 
+      #: (String buf, Elements::RichText rich_text) -> void
+      def write_inline_rich_text(buf, rich_text)
+        buf << "><is>"
+        rich_text.runs.each do |run|
+          font = run[:font]
+          if font && !font.empty?
+            buf << "<r><rPr>"
+            buf << "<b/>" if font[:bold]
+            buf << "<i/>" if font[:italic]
+            buf << "<strike/>" if font[:strike]
+            if font[:underline]
+              u_val = font[:underline]
+              if u_val == true || u_val.to_s == "single"
+                buf << "<u/>"
+              else
+                mapped_u = StyleBuilder::UNDERLINE_MAP[u_val.to_sym] || u_val
+                buf << '<u val="' << mapped_u.to_s << '"/>'
+              end
+            end
+            va_val = font[:vert_align] || font[:vertical_align]
+            va_val ||= "superscript" if font[:superscript]
+            va_val ||= "subscript" if font[:subscript]
+            if va_val
+              mapped_va = StyleBuilder::VERT_ALIGN_MAP[va_val.to_sym] || va_val
+              buf << '<vertAlign val="' << mapped_va.to_s << '"/>'
+            end
+            font_sz = font[:sz] || font[:size]
+            buf << '<sz val="' << font_sz.to_s << '"/>' if font_sz
+            if font[:color]
+              if font[:color].is_a?(Hash)
+                c_hash = font[:color]
+                if c_hash[:rgb]
+                  norm = StyleBuilder.normalize_color(c_hash[:rgb], alpha: true) || c_hash[:rgb].to_s
+                  buf << '<color rgb="' << norm << '"/>'
+                elsif c_hash[:theme]
+                  tint_attr = c_hash[:tint] ? %( tint="#{c_hash[:tint]}") : ""
+                  buf << '<color theme="' << c_hash[:theme].to_s << '"' << tint_attr << "/>"
+                elsif c_hash[:indexed]
+                  buf << '<color indexed="' << c_hash[:indexed].to_s << '"/>'
+                elsif c_hash[:auto]
+                  buf << '<color auto="1"/>'
+                end
+              else
+                raw_color = font[:color]
+                norm_color = StyleBuilder.normalize_color(raw_color, alpha: true) || raw_color.to_s
+                buf << '<color rgb="' << norm_color << '"/>'
+              end
+            elsif font[:theme]
+              tint_attr = font[:tint] ? %( tint="#{font[:tint]}") : ""
+              buf << '<color theme="' << font[:theme].to_s << '"' << tint_attr << "/>"
+            elsif font[:indexed]
+              buf << '<color indexed="' << font[:indexed].to_s << '"/>'
+            elsif font[:auto]
+              buf << '<color auto="1"/>'
+            end
+            buf << '<rFont val="' << escape_xml(font[:name]) << '"/>' if font[:name]
+            buf << '<family val="' << font[:family].to_s << '"/>' if font[:family]
+            buf << '<scheme val="' << font[:scheme].to_s << '"/>' if font[:scheme]
+            buf << "</rPr><t>"
+          else
+            buf << "<r><t>"
+          end
+          buf << escape_xml(run[:text].to_s) << "</t></r>"
+        end
+        buf << "</is></c>"
+      end
+
       INVALID_XML_CHARS_RE = /[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/
       ESCAPE_RE = /[&<>"']/
       ESCAPE_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;", "'" => "&apos;" }.freeze