xlsxrb 0.1.15 → 0.1.17

data/lib/xlsxrb/ooxml/workbook_writer.rb

@@ -32,19 +32,22 @@ module Xlsxrb
 
       def self.write(target, sheets:, shared_strings: [], shared_strings_index: nil, styles: nil,
                      defined_names: nil, core_properties: nil, app_properties: nil,
-                     custom_properties: nil, workbook_protection: nil, workbook_properties: nil)
+                     custom_properties: nil, workbook_protection: nil, workbook_properties: nil,
+                     compression_level: Zlib::DEFAULT_COMPRESSION)
         writer = new(sheets: sheets, shared_strings: shared_strings, shared_strings_index: shared_strings_index, styles: styles,
                      defined_names: defined_names, core_properties: core_properties,
                      app_properties: app_properties, custom_properties: custom_properties,
-                     workbook_protection: workbook_protection, workbook_properties: workbook_properties)
+                     workbook_protection: workbook_protection, workbook_properties: workbook_properties,
+                     compression_level: compression_level)
         writer.write_to(target)
       end
 
       def initialize(sheets:, shared_strings: [], shared_strings_index: nil, styles: nil,
                      defined_names: nil, core_properties: nil, app_properties: nil,
-                     custom_properties: nil, workbook_protection: nil, workbook_properties: nil)
+                     custom_properties: nil, workbook_protection: nil, workbook_properties: nil,
+                     compression_level: Zlib::DEFAULT_COMPRESSION)
         @sheets = sheets
-        @shared_strings = shared_strings
+        @shared_strings = shared_strings || []
         @shared_strings_index = shared_strings_index
         @styles = styles || {}
         @defined_names = defined_names || []
@@ -53,27 +56,42 @@ module Xlsxrb
         @custom_properties = custom_properties || []
         @workbook_protection = workbook_protection
         @workbook_properties = workbook_properties || { update_links: "never" }
+        @compression_level = compression_level || Zlib::DEFAULT_COMPRESSION
         @drawing_count = 0
         @chart_count = 0
         @comment_count = 0
         @table_count = 0
         @pivot_cache_count = 0
         @pivot_table_count = 0
+        @threaded_comment_count = 0
+        @persons = []
       end
 
       def write_to(target)
         preprocess_conditional_formats!
 
-        ZipWriter.open(target) do |zip|
+        active_tab_idx = resolve_active_tab_index
+        effective_active_idx = active_tab_idx || 0
+
+        ZipWriter.open(target, compression_level: @compression_level) do |zip|
           @sheets.each_with_index do |sheet, idx|
             info = prepare_sheet_auxiliary(sheet, idx)
             sheet_tables = sheet[:tables] || []
 
+            sv = sheet[:sheet_view]
+            if idx == effective_active_idx
+              sv = (sv || {}).merge(tab_selected: true)
+            elsif sv&.key?(:tab_selected)
+              sv = sv.dup
+              sv.delete(:tab_selected)
+            end
+
             zip.start_entry("xl/worksheets/sheet#{idx + 1}.xml")
             write_worksheet_xml(
               ZipEntryIO.new(zip),
               sheet,
               drawing_rid: info[:drawing_rid],
+              picture_rid: info[:picture_rid],
               sheet_protection: sheet[:sheet_protection],
               auto_filter: sheet[:auto_filter],
               filter_columns: sheet[:filter_columns],
@@ -91,11 +109,14 @@ module Xlsxrb
               freeze_pane: sheet[:freeze_pane],
               split_pane: sheet[:split_pane],
               selection: sheet[:selection],
-              sheet_view: sheet[:sheet_view],
+              sheet_view: sv,
               sheet_properties: sheet[:sheet_properties],
               sheet_format: sheet[:sheet_format],
               protected_ranges: sheet[:protected_ranges],
               cell_watches: sheet[:cell_watches],
+              ignored_errors: sheet[:ignored_errors],
+              phonetic_pr: sheet[:phonetic_properties] || sheet[:phonetic_pr],
+              sheet_calc_pr: sheet[:sheet_calc_pr],
               tables: sheet_tables,
               table_start_rid: info[:table_start_rid],
               legacy_drawing_rid: info[:vml_rid],
@@ -108,20 +129,23 @@ module Xlsxrb
         end
       end
 
-      def prepare_sheet_auxiliary(sheet, _idx)
+      def prepare_sheet_auxiliary(sheet, idx)
         sheet_images = sheet[:images] || []
         sheet_charts = sheet[:charts] || []
         sheet_shapes = sheet[:shapes] || []
         sheet_comments = sheet[:comments] || []
+        sheet_threaded_comments = sheet[:threaded_comments] || []
         sheet_tables = sheet[:tables] || []
         sheet_hyperlinks = sheet[:hyperlinks] || []
         has_drawing = sheet_images.any? || sheet_charts.any? || sheet_shapes.any?
         has_comments = sheet_comments.any?
+        has_threaded_comments = sheet_threaded_comments.any?
 
         sheet_rels = []
         drawing_rid = nil
         vml_rid = nil
         table_start_rid = nil
+        picture_rid = nil
         hyperlink_rels = []
 
         if has_drawing
@@ -140,6 +164,12 @@ module Xlsxrb
           vml_rid = "rId#{vml_rid_num}"
         end
 
+        if has_threaded_comments
+          @threaded_comment_count += 1
+          tc_rid_num = sheet_rels.size + 1
+          sheet_rels << { id: "rId#{tc_rid_num}", type: "http://schemas.microsoft.com/office/2017/10/relationships/threadedComment", target: "../threadedComments/threadedComment#{@threaded_comment_count}.xml" }
+        end
+
         sheet_hyperlinks.each do |link|
           next unless link[:url]
 
@@ -178,6 +208,33 @@ module Xlsxrb
           end
         end
 
+        bg_img = sheet[:background_image] || sheet[:background_picture] || sheet[:picture]
+        if bg_img
+          bg_data = if bg_img.is_a?(Hash)
+                      bg_img[:file_data] || bg_img[:data]
+                    else
+                      (bg_img.respond_to?(:data) ? bg_img.data : bg_img)
+                    end
+          if bg_data.is_a?(String) && !bg_data.include?("\x00") && File.file?(bg_data)
+            bg_ext = File.extname(bg_data).delete_prefix(".").downcase
+            bg_data = File.binread(bg_data)
+          else
+            bg_ext = if bg_img.is_a?(Hash)
+                       (bg_img[:ext] || (bg_img[:filename] && File.extname(bg_img[:filename]).delete_prefix(".")) || "png").to_s.downcase
+                     elsif bg_img.respond_to?(:filename)
+                       File.extname(bg_img.filename).delete_prefix(".").downcase
+                     else
+                       "png"
+                     end
+          end
+          if bg_data && !bg_data.empty?
+            p_rid_num = sheet_rels.size + 1
+            picture_rid = "rId#{p_rid_num}"
+            sheet_rels << { id: picture_rid, type: "#{DOC_REL}/image", target: "../media/sheet#{idx + 1}_bg.#{bg_ext}" }
+            sheet[:_bg_media] = { path: "xl/media/sheet#{idx + 1}_bg.#{bg_ext}", data: bg_data.b, ext: bg_ext }
+          end
+        end
+
         sheet[:_prepared_rels] = sheet_rels
         sheet[:_enriched_hyperlinks] = enriched_hyperlinks
 
@@ -185,6 +242,7 @@ module Xlsxrb
           drawing_rid: drawing_rid,
           vml_rid: vml_rid,
           table_start_rid: table_start_rid,
+          picture_rid: picture_rid,
           enriched_hyperlinks: enriched_hyperlinks,
           sheet_rels: sheet_rels
         }
@@ -193,6 +251,7 @@ module Xlsxrb
       def write_auxiliary_parts(zip)
         drawing_idx = 0
         comment_idx = 0
+        tc_idx = 0
         table_idx = 0
         pivot_cache_idx = 0
         pivot_table_idx = 0
@@ -268,6 +327,29 @@ module Xlsxrb
             zip.add_entry("xl/drawings/vmlDrawing#{comment_idx}.vml", comment_writer.send(:generate_vml_drawing_xml, comment_writer.comments))
           end
 
+          sheet_threaded_comments = sheet[:threaded_comments] || []
+          if sheet_threaded_comments.any?
+            tc_idx += 1
+            tc_writer = Xlsxrb::Ooxml::Writer.new
+            sheet_threaded_comments.each do |c|
+              tc_writer.add_threaded_comment(
+                c[:cell] || c[:ref],
+                c[:text],
+                author: c[:author] || "Author",
+                timestamp: c[:timestamp] || c[:dt],
+                id: c[:id],
+                parent_id: c[:parent_id],
+                done: c[:done],
+                user_id: c[:user_id],
+                provider_id: c[:provider_id]
+              )
+            end
+            tc_writer.persons.each do |p|
+              @persons << p unless @persons.any? { |ep| ep[:id] == p[:id] || ep[:display_name] == p[:display_name] }
+            end
+            zip.add_entry("xl/threadedComments/threadedComment#{tc_idx}.xml", tc_writer.send(:generate_threaded_comments_xml, tc_writer.threaded_comments))
+          end
+
           sheet_tables.each do |tbl|
             table_idx += 1
             zip.add_entry("xl/tables/table#{table_idx}.xml", build_table_xml(tbl, table_idx))
@@ -308,8 +390,15 @@ module Xlsxrb
             end
           end
 
+          zip.add_binary_entry(sheet[:_bg_media][:path], sheet[:_bg_media][:data]) if sheet[:_bg_media]
+
           zip.add_entry("xl/worksheets/_rels/sheet#{idx + 1}.xml.rels", build_sheet_rels_from_list(sheet_rels)) unless sheet_rels.empty?
         end
+
+        return unless @persons.any?
+
+        p_writer = Xlsxrb::Ooxml::Writer.new
+        zip.add_entry("xl/persons/person.xml", p_writer.send(:generate_persons_xml, @persons))
       end
 
       def write_package_metadata(zip)
@@ -407,6 +496,23 @@ module Xlsxrb
             end
           end
 
+          if sheet[:_bg_media]
+            bg_ext = sheet[:_bg_media][:ext]
+            unless image_exts[bg_ext]
+              mime = case bg_ext
+                     when "png" then "image/png"
+                     when "jpg", "jpeg" then "image/jpeg"
+                     when "gif" then "image/gif"
+                     when "bmp" then "image/bmp"
+                     when "emf" then "image/x-emf"
+                     when "wmf" then "image/x-wmf"
+                     else "application/octet-stream"
+                     end
+              b.empty_tag("Default", { Extension: bg_ext, ContentType: mime })
+              image_exts[bg_ext] = true
+            end
+          end
+
           if sheet_comments.any?
             comment_count += 1
             b.empty_tag("Override", { PartName: "/xl/comments#{comment_count}.xml", ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml" })
@@ -427,6 +533,11 @@ module Xlsxrb
           end
         end
 
+        b.empty_tag("Override", { PartName: "/xl/persons/person.xml", ContentType: "application/vnd.ms-excel.person+xml" }) if @persons.any?
+        (1..@threaded_comment_count).each do |tc|
+          b.empty_tag("Override", { PartName: "/xl/threadedComments/threadedComment#{tc}.xml", ContentType: "application/vnd.ms-excel.threadedcomments+xml" })
+        end
+
         b.close_tag("Types")
         io.string
       end
@@ -484,6 +595,7 @@ module Xlsxrb
           attrs = {}
           attrs[:date1904] = "1" if @workbook_properties[:date1904]
           attrs[:updateLinks] = @workbook_properties[:update_links] if @workbook_properties[:update_links]
+          attrs[:codeName] = @workbook_properties[:code_name] if @workbook_properties[:code_name]
           b.empty_tag("workbookPr", attrs) unless attrs.empty?
         end
 
@@ -496,6 +608,26 @@ module Xlsxrb
           b.empty_tag("workbookProtection", wp_attrs) unless wp_attrs.empty?
         end
 
+        # Workbook view: activeTab, firstSheet, showSheetTabs, tabRatio
+        active_tab_idx = resolve_active_tab_index
+        first_sheet_idx = resolve_first_sheet_index
+        show_sheet_tabs = @workbook_properties&.[](:show_sheet_tabs)
+        tab_ratio = @workbook_properties&.[](:tab_ratio)
+
+        emit_active_tab = !@workbook_properties&.[](:active_tab).nil? || active_tab_idx&.positive?
+
+        has_book_views = emit_active_tab || first_sheet_idx || !show_sheet_tabs.nil? || tab_ratio
+        if has_book_views
+          bv_attrs = {}
+          bv_attrs[:activeTab] = active_tab_idx.to_s if emit_active_tab
+          bv_attrs[:firstSheet] = first_sheet_idx.to_s if first_sheet_idx
+          bv_attrs[:showSheetTabs] = show_sheet_tabs ? "1" : "0" unless show_sheet_tabs.nil?
+          bv_attrs[:tabRatio] = tab_ratio.to_s if tab_ratio
+          b.open_tag("bookViews")
+          b.empty_tag("workbookView", bv_attrs)
+          b.close_tag("bookViews")
+        end
+
         b.open_tag("sheets")
         @sheets.each_with_index do |sheet, idx|
           s_name = sheet.respond_to?(:name) ? sheet.name : sheet[:name]
@@ -531,6 +663,9 @@ module Xlsxrb
           b.close_tag("definedNames")
         end
 
+        # Calculation properties: ask Excel to recalculate every formula when the file is opened
+        b.empty_tag("calcPr", { fullCalcOnLoad: "1" }) if @workbook_properties&.[](:full_calc_on_load)
+
         # Pivot caches
         total_pivots = @sheets.sum { |s| (s[:pivot_tables] || []).size }
         if total_pivots.positive?
@@ -586,6 +721,15 @@ module Xlsxrb
                       })
         end
 
+        if @persons.any?
+          rid += 1
+          b.empty_tag("Relationship", {
+                        Id: "rId#{rid}",
+                        Type: "http://schemas.microsoft.com/office/2017/10/relationships/person",
+                        Target: "persons/person.xml"
+                      })
+        end
+
         b.close_tag("Relationships")
         io.string
       end
@@ -597,7 +741,11 @@ module Xlsxrb
         b.open_tag("styleSheet", { xmlns: SSML_NS })
 
         # Number formats
-        raw_num_fmts = @styles&.dig(:num_fmts) || []
+        raw_num_fmts = if @styles.respond_to?(:num_fmts)
+                         @styles.num_fmts
+                       else
+                         @styles&.dig(:num_fmts) || []
+                       end
         num_fmts = if raw_num_fmts.is_a?(Hash)
                      raw_num_fmts.map { |k, v| { num_fmt_id: k.to_i, format_code: v.to_s } }
                    elsif raw_num_fmts.is_a?(Array)
@@ -622,7 +770,11 @@ module Xlsxrb
         end
 
         # Fonts
-        fonts = @styles&.dig(:fonts) || []
+        fonts = if @styles.respond_to?(:fonts)
+                  @styles.fonts
+                else
+                  @styles&.dig(:fonts) || []
+                end
         fonts = [{}] if fonts.empty? # At least one default font
         b.tag("fonts", { count: fonts.size.to_s }) do |_|
           fonts.each do |font_props|
@@ -631,17 +783,38 @@ module Xlsxrb
               b.empty_tag("i") if font_props[:italic]
               b.empty_tag("strike") if font_props[:strike]
               if font_props[:underline]
-                b.empty_tag("u", font_props[:underline] == "single" ? {} : { val: font_props[:underline] })
+                u_val = font_props[:underline]
+                if u_val == true || u_val.to_s == "single"
+                  b.empty_tag("u")
+                else
+                  mapped_u = StyleBuilder::UNDERLINE_MAP[u_val.to_sym] || u_val.to_s
+                  b.empty_tag("u", { val: mapped_u })
+                end
+              end
+              va_val = font_props[:vert_align] || font_props[:vertical_align]
+              va_val ||= "superscript" if font_props[:superscript]
+              va_val ||= "subscript" if font_props[:subscript]
+              if va_val
+                mapped_va = StyleBuilder::VERT_ALIGN_MAP[va_val.to_sym] || va_val.to_s
+                b.empty_tag("vertAlign", { val: mapped_va })
               end
               b.empty_tag("sz", { val: (font_props[:sz] || 11).to_s }) if font_props[:sz] || fonts == [{}]
-              b.empty_tag("color", { rgb: font_props[:color] }) if font_props[:color]
+              color_attrs = color_tag_attrs(font_props[:color] || (font_props.key?(:rgb) || font_props.key?(:theme) || font_props.key?(:indexed) ? font_props : nil))
+              b.empty_tag("color", color_attrs) if color_attrs
               b.empty_tag("name", { val: font_props[:name] || "Calibri" })
+              b.empty_tag("family", { val: font_props[:family].to_s }) if font_props[:family]
+              b.empty_tag("charset", { val: font_props[:charset].to_s }) if font_props[:charset]
+              b.empty_tag("scheme", { val: font_props[:scheme].to_s }) if font_props[:scheme]
             end
           end
         end
 
         # Fills
-        fills = @styles&.dig(:fills) || []
+        fills = if @styles.respond_to?(:fills)
+                  @styles.fills
+                else
+                  @styles&.dig(:fills) || []
+                end
         fills = [{ pattern: "none" }, { pattern: "gray125" }] if fills.empty?
         b.tag("fills", { count: fills.size.to_s }) do |_|
           fills.each do |fill_props|
@@ -650,14 +823,18 @@ module Xlsxrb
                 b.open_tag("gradientFill", { type: fill_props[:gradient][:type], degree: fill_props[:gradient][:degree]&.to_s }.compact)
                 fill_props[:gradient][:stops].each do |stop|
                   b.tag("stop", { position: stop[:position].to_s }) do |_|
-                    b.empty_tag("color", { rgb: stop[:color] })
+                    c_attrs = color_tag_attrs(stop[:color] || stop)
+                    b.empty_tag("color", c_attrs) if c_attrs
                   end
                 end
                 b.close_tag("gradientFill")
               else
                 b.tag("patternFill", { patternType: fill_props[:pattern] || "none" }) do |_|
-                  b.empty_tag("fgColor", { rgb: fill_props[:fg_color] }) if fill_props[:fg_color]
-                  b.empty_tag("bgColor", { rgb: fill_props[:bg_color] }) if fill_props[:bg_color]
+                  fg_attrs = color_tag_attrs(fill_props[:fg_color] || (fill_props[:fg_color_theme] ? { theme: fill_props[:fg_color_theme], tint: fill_props[:fg_color_tint] } : nil) || (fill_props[:fg_color_indexed] ? { indexed: fill_props[:fg_color_indexed] } : nil))
+                  b.empty_tag("fgColor", fg_attrs) if fg_attrs
+
+                  bg_attrs = color_tag_attrs(fill_props[:bg_color] || (fill_props[:bg_color_theme] ? { theme: fill_props[:bg_color_theme], tint: fill_props[:bg_color_tint] } : nil) || (fill_props[:bg_color_indexed] ? { indexed: fill_props[:bg_color_indexed] } : nil))
+                  b.empty_tag("bgColor", bg_attrs) if bg_attrs
                 end
               end
             end
@@ -665,7 +842,11 @@ module Xlsxrb
         end
 
         # Borders
-        borders = @styles&.dig(:borders) || []
+        borders = if @styles.respond_to?(:borders)
+                    @styles.borders
+                  else
+                    @styles&.dig(:borders) || []
+                  end
         borders = [{}] if borders.empty?
         b.tag("borders", { count: borders.size.to_s }) do |_|
           borders.each do |border_props|
@@ -677,16 +858,8 @@ module Xlsxrb
                 side_data = border_props[side]
                 if side_data
                   b.tag(side.to_s, { style: side_data[:style] }) do |_|
-                    c = side_data[:color]
-                    if c.is_a?(Hash)
-                      c_attrs = {}
-                      c_attrs[:rgb] = c[:rgb] if c[:rgb]
-                      c_attrs[:theme] = c[:theme].to_s if c[:theme]
-                      c_attrs[:tint] = c[:tint].to_s if c[:tint]
-                      b.empty_tag("color", c_attrs) unless c_attrs.empty?
-                    elsif c
-                      b.empty_tag("color", { rgb: c })
-                    end
+                    c_attrs = color_tag_attrs(side_data[:color])
+                    b.empty_tag("color", c_attrs) if c_attrs
                   end
                 else
                   b.empty_tag(side.to_s)
@@ -702,7 +875,11 @@ module Xlsxrb
         end
 
         # Cell XFs (formatting)
-        xf_entries = @styles&.dig(:cell_xfs) || @styles&.dig(:xf_entries) || []
+        xf_entries = if @styles.respond_to?(:cell_xfs)
+                       @styles.cell_xfs
+                     else
+                       @styles&.dig(:cell_xfs) || @styles&.dig(:xf_entries) || []
+                     end
         xf_count = [xf_entries.size, 1].max
         b.tag("cellXfs", { count: xf_count.to_s }) do |_|
           xf_entries.each do |xf|
@@ -751,7 +928,11 @@ module Xlsxrb
         end
 
         # Differential formats (for conditional formatting)
-        dxfs = @styles&.dig(:dxfs) || []
+        dxfs = if @styles.respond_to?(:dxfs)
+                 @styles.dxfs
+               else
+                 @styles&.dig(:dxfs) || []
+               end
         unless dxfs.empty?
           b.tag("dxfs", { count: dxfs.size.to_s }) do |_|
             dxfs.each do |dxf|
@@ -762,6 +943,9 @@ module Xlsxrb
                   b.empty_tag("numFmt", { numFmtId: nf[:num_fmt_id].to_s, formatCode: nf[:format_code].to_s })
                 end
                 write_dxf_fill(b, dxf[:fill]) if dxf[:fill]
+                write_dxf_alignment(b, dxf[:alignment]) if dxf[:alignment]
+                write_dxf_border(b, dxf[:border]) if dxf[:border]
+                write_dxf_protection(b, dxf[:protection]) if dxf[:protection]
               end
             end
           end
@@ -772,8 +956,6 @@ module Xlsxrb
       end
 
       def preprocess_conditional_formats!
-        @styles[:dxfs] ||= []
-
         @sheets.each do |sheet|
           rules = sheet[:conditional_formats]
           next if rules.nil? || rules.empty?
@@ -785,11 +967,15 @@ module Xlsxrb
             dxf = normalized.delete(:dxf) || extract_dxf_from_rule!(normalized)
             next normalized unless dxf
 
-            dxf_id = @styles[:dxfs].index(dxf)
-            unless dxf_id
-              @styles[:dxfs] << dxf
-              dxf_id = @styles[:dxfs].size - 1
-            end
+            dxf_id = if @styles.respond_to?(:add_dxf)
+                       @styles.dxfs.index(dxf) || @styles.add_dxf(dxf)
+                     else
+                       @styles[:dxfs] ||= []
+                       @styles[:dxfs].index(dxf) || begin
+                         @styles[:dxfs] << dxf
+                         @styles[:dxfs].size - 1
+                       end
+                     end
             normalized[:format_id] = dxf_id
             normalized
           end
@@ -797,48 +983,162 @@ module Xlsxrb
       end
 
       def extract_dxf_from_rule!(rule)
-        font = {}
-        font[:color] = rule.delete(:font_color) if rule.key?(:font_color)
-        font[:bold] = rule.delete(:bold) if rule.key?(:bold)
-        font[:italic] = rule.delete(:italic) if rule.key?(:italic)
-        font[:underline] = rule.delete(:underline) if rule.key?(:underline)
-
-        fill = {}
-        if rule.key?(:fill_color)
-          fill[:pattern] = "solid"
-          fill[:fg_color] = rule.delete(:fill_color)
-        end
-
-        dxf = {}
-        dxf[:font] = font unless font.empty?
-        dxf[:fill] = fill unless fill.empty?
-        dxf.empty? ? nil : dxf
+        DslHelpers.extract_dxf_from_rule!(rule)
       end
 
       def write_dxf_font(builder, font)
         builder.tag("font") do |_|
-          builder.empty_tag("b") if font[:bold]
-          builder.empty_tag("i") if font[:italic]
+          if font.key?(:bold)
+            font[:bold] ? builder.empty_tag("b") : builder.empty_tag("b", { val: "0" })
+          end
+          if font.key?(:italic)
+            font[:italic] ? builder.empty_tag("i") : builder.empty_tag("i", { val: "0" })
+          end
+          if font.key?(:strike)
+            font[:strike] ? builder.empty_tag("strike") : builder.empty_tag("strike", { val: "0" })
+          end
           if font[:underline]
-            if font[:underline] == true
+            if [true, "single"].include?(font[:underline])
               builder.empty_tag("u")
             else
-              builder.empty_tag("u", { val: font[:underline] })
+              mapped_u = StyleBuilder::UNDERLINE_MAP[font[:underline].to_sym] || font[:underline]
+              builder.empty_tag("u", { val: mapped_u })
             end
           end
-          builder.empty_tag("color", { rgb: font[:color] }) if font[:color]
+          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.to_s
+            builder.empty_tag("vertAlign", { val: mapped_va })
+          end
+          color_attrs = color_tag_attrs(font[:color] || font)
+          builder.empty_tag("color", color_attrs) if color_attrs
           builder.empty_tag("name", { val: font[:name] }) if font[:name]
-          builder.empty_tag("sz", { val: font[:sz].to_s }) if font[:sz]
+          sz_val = font[:sz] || font[:size]
+          builder.empty_tag("sz", { val: sz_val.to_s }) if sz_val
         end
       end
 
       def write_dxf_fill(builder, fill)
         builder.tag("fill") do |_|
-          pattern = fill[:pattern] || "solid"
-          builder.tag("patternFill", { patternType: pattern }) do |_|
-            builder.empty_tag("fgColor", { rgb: fill[:fg_color] }) if fill[:fg_color]
-            builder.empty_tag("bgColor", { rgb: fill[:bg_color] }) if fill[:bg_color]
+          pattern_attrs = {}
+          pattern = fill[:pattern] || fill[:pattern_type]
+          pattern ||= "solid" if (fill[:color] || fill[:fill_color] || fill[:fg_color]) && !fill[:bg_color]
+          pattern_attrs[:patternType] = pattern if pattern
+          builder.tag("patternFill", pattern_attrs) do |_|
+            fg = fill[:fg_color] || fill[:color] || fill[:fill_color]
+            fg_attrs = color_tag_attrs(fg)
+            builder.empty_tag("fgColor", fg_attrs) if fg_attrs
+            bg_attrs = color_tag_attrs(fill[:bg_color])
+            builder.empty_tag("bgColor", bg_attrs) if bg_attrs
+          end
+        end
+      end
+
+      def write_dxf_alignment(builder, alignment)
+        return if alignment.nil? || alignment.empty?
+
+        align_attrs = {}
+        align_attrs[:horizontal] = alignment[:horizontal] if alignment[:horizontal]
+        align_attrs[:vertical] = alignment[:vertical] if alignment[:vertical]
+        align_attrs[:wrapText] = "1" if alignment[:wrap_text]
+        align_attrs[:textRotation] = alignment[:text_rotation].to_s if alignment[:text_rotation]
+        align_attrs[:indent] = alignment[:indent].to_s if alignment[:indent]
+        align_attrs[:relativeIndent] = alignment[:relative_indent].to_s if alignment[:relative_indent]
+        align_attrs[:shrinkToFit] = "1" if alignment[:shrink_to_fit]
+        align_attrs[:readingOrder] = alignment[:reading_order].to_s if alignment[:reading_order]
+        align_attrs[:justifyLastLine] = "1" if alignment[:justify_last_line]
+        builder.empty_tag("alignment", align_attrs) unless align_attrs.empty?
+      end
+
+      def write_dxf_border(builder, border)
+        return if border.nil? || border.empty?
+
+        border_attrs = {}
+        border_attrs[:diagonalUp] = "1" if border[:diagonal_up]
+        border_attrs[:diagonalDown] = "1" if border[:diagonal_down]
+
+        builder.tag("border", border_attrs) do |_|
+          %i[left right top bottom diagonal].each do |side|
+            side_data = border[side]
+            next unless side_data
+
+            tag_attrs = {}
+            tag_attrs[:style] = side_data[:style] if side_data[:style]
+            c_attrs = color_tag_attrs(side_data[:color])
+            if c_attrs
+              builder.tag(side.to_s, tag_attrs) do |_|
+                builder.empty_tag("color", c_attrs)
+              end
+            elsif !tag_attrs.empty?
+              builder.empty_tag(side.to_s, tag_attrs)
+            else
+              builder.empty_tag(side.to_s)
+            end
+          end
+        end
+      end
+
+      def write_dxf_protection(builder, protection)
+        return if protection.nil? || protection.empty?
+
+        prot_attrs = {}
+        prot_attrs[:locked] = protection[:locked] ? "1" : "0" unless protection[:locked].nil?
+        prot_attrs[:hidden] = protection[:hidden] ? "1" : "0" unless protection[:hidden].nil?
+        builder.empty_tag("protection", prot_attrs) unless prot_attrs.empty?
+      end
+
+      # : (untyped rgb) -> ::String?
+      def format_rgb_hex(rgb)
+        return nil unless rgb
+
+        str = rgb.to_s.sub(/^#/, "").strip
+        return nil if str.empty?
+
+        case str
+        when /\A[0-9a-fA-F]{8}\z/
+          str.upcase
+        when /\A[0-9a-fA-F]{6}\z/
+          "FF#{str.upcase}"
+        when /\A[0-9a-fA-F]{3}\z/
+          r, g, b = str.chars
+          "FF#{r}#{r}#{g}#{g}#{b}#{b}".upcase
+        else
+          resolved = StyleBuilder.resolve_color(rgb)
+          case resolved
+          when /\A[0-9a-fA-F]{8}\z/
+            resolved.upcase
+          when /\A[0-9a-fA-F]{6}\z/
+            "FF#{resolved.upcase}"
+          end
+        end
+      end
+
+      # : (untyped spec) -> ::Hash[Symbol, ::String]?
+      def color_tag_attrs(spec)
+        return nil unless spec
+
+        spec = spec[:color] if spec.is_a?(Hash) && spec[:color].is_a?(Hash)
+        return nil unless spec
+
+        if spec.is_a?(Hash)
+          if spec[:auto]
+            { auto: "1" }
+          elsif spec[:rgb] || (spec[:color] && !spec[:color].is_a?(Hash))
+            raw_rgb = spec[:rgb] || spec[:color]
+            fmt = format_rgb_hex(raw_rgb)
+            fmt ? { rgb: fmt } : nil
+          elsif spec[:theme]
+            attrs = { theme: spec[:theme].to_s }
+            attrs[:tint] = spec[:tint].to_s if spec[:tint]
+            attrs
+          elsif spec[:indexed]
+            { indexed: spec[:indexed].to_s }
           end
+        elsif spec.is_a?(String) || spec.is_a?(Symbol)
+          fmt = format_rgb_hex(spec)
+          fmt ? { rgb: fmt } : nil
         end
       end
 
@@ -849,6 +1149,7 @@ module Xlsxrb
 
       def escape_xml(value)
         str = value.to_s
+        str = str.dup.force_encoding(Encoding::UTF_8) if str.encoding == Encoding::BINARY
         str = str.gsub(INVALID_XML_CHARS_RE, "") if str.match?(INVALID_XML_CHARS_RE)
         str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
       end
@@ -873,19 +1174,26 @@ module Xlsxrb
                 buf << "<i/>" if font[:italic]
                 buf << "<strike/>" if font[:strike]
                 if font[:underline]
-                  if font[:underline] == true
+                  if font[:underline] == true || font[:underline].to_s == "single"
                     buf << "<u/>"
                   else
-                    buf << '<u val="' << font[:underline].to_s << '"/>'
+                    mapped_u = StyleBuilder::UNDERLINE_MAP[font[:underline].to_sym] || font[:underline]
+                    buf << '<u val="' << mapped_u.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 << "/>"
+                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.to_s
+                  buf << '<vertAlign val="' << mapped_va << '"/>'
+                end
+                font_sz = font[:sz] || font[:size]
+                buf << '<sz val="' << font_sz.to_s << '"/>' if font_sz
+                color_attrs = color_tag_attrs(font[:color] || font)
+                if color_attrs
+                  attrs_str = color_attrs.map { |k, v| %(#{k}="#{v}") }.join(" ")
+                  buf << "<color #{attrs_str}/>"
                 end
                 buf << '<rFont val="' << escape_xml(font[:name]) << '"/>' if font[:name]
                 buf << '<family val="' << font[:family].to_s << '"/>' if font[:family]
@@ -894,17 +1202,11 @@ module Xlsxrb
               else
                 buf << "<r><t>"
               end
-              buf << escape_xml(run[:text]) << "</t></r>"
+              buf << escape_xml(run[:text].to_s) << "</t></r>"
             end
             buf << "</si>"
           else
-            s = str.to_s
-            needs_space = s.start_with?(" ", "\t", "\n") || s.end_with?(" ", "\t", "\n")
-            if needs_space
-              buf << '<si><t xml:space="preserve">' << escape_xml(s) << "</t></si>"
-            else
-              buf << "<si><t>" << escape_xml(s) << "</t></si>"
-            end
+            buf << "<si><t>" << escape_xml(str.to_s) << "</t></si>"
           end
 
           if buf.bytesize >= 32_768
@@ -919,16 +1221,17 @@ module Xlsxrb
         zip.finish_entry
       end
 
-      def write_worksheet_xml(io, sheet, drawing_rid: nil, sheet_protection: nil,
+      def write_worksheet_xml(io, sheet, 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, freeze_pane: nil, split_pane: nil,
+                              cell_watches: nil, ignored_errors: nil, freeze_pane: nil, split_pane: nil,
                               selection: nil, sheet_view: nil, sheet_properties: nil,
                               sheet_format: nil, tables: nil, table_start_rid: nil,
-                              legacy_drawing_rid: nil, sparkline_groups: nil)
+                              legacy_drawing_rid: nil, sparkline_groups: nil, phonetic_pr: nil,
+                              sheet_calc_pr: nil)
         date1904 = @workbook_properties&.[](:date1904) ? true : false
         ws = WorksheetWriter.new(io, date1904: date1904)
         ws.start(
@@ -964,6 +1267,7 @@ module Xlsxrb
         end
         ws.finish(
           drawing_rid: drawing_rid,
+          picture_rid: picture_rid,
           sheet_protection: sheet_protection,
           protected_ranges: protected_ranges,
           auto_filter: auto_filter,
@@ -980,10 +1284,13 @@ module Xlsxrb
           row_breaks: row_breaks,
           col_breaks: col_breaks,
           cell_watches: cell_watches,
+          ignored_errors: ignored_errors,
           tables: tables,
           table_start_rid: table_start_rid,
           legacy_drawing_rid: legacy_drawing_rid,
-          sparkline_groups: sparkline_groups
+          sparkline_groups: sparkline_groups,
+          phonetic_pr: phonetic_pr,
+          sheet_calc_pr: sheet_calc_pr
         )
       end
 
@@ -1002,14 +1309,36 @@ module Xlsxrb
         t_attrs[:totalsRowCount] = tbl[:totals_row_count].to_s if tbl[:totals_row_count]&.positive?
         b.open_tag("table", t_attrs)
 
-        # Auto filter for the table range
-        b.empty_tag("autoFilter", { ref: tbl[:ref] })
+        # Auto filter for the table range unless auto_filter: false
+        b.empty_tag("autoFilter", { ref: tbl[:ref] }) unless tbl[:auto_filter] == false
 
         # Table columns
         columns = tbl[:columns] || []
         b.open_tag("tableColumns", { count: columns.size.to_s })
-        columns.each_with_index do |col_name, ci|
-          b.empty_tag("tableColumn", { id: (ci + 1).to_s, name: col_name })
+        columns.each_with_index do |col, ci|
+          col_name = col.is_a?(Hash) ? col[:name] : col
+          col_attrs = { id: (ci + 1).to_s, name: col_name.to_s }
+          calc_formula = nil
+          tot_formula = nil
+          if col.is_a?(Hash)
+            calc_formula = col[:calculated_column_formula] || col[:data_formula] || col[:formula]
+            tot_formula = col[:totals_row_formula] || col[:total_row_formula] || col[:total_formula]
+            trf = col[:totals_row_function] || ("custom" if tot_formula)
+            col_attrs[:totalsRowFunction] = trf.to_s if trf
+            col_attrs[:totalsRowLabel] = col[:totals_row_label].to_s if col[:totals_row_label]
+            col_attrs[:dataDxfId] = col[:data_dxf_id].to_s if col[:data_dxf_id]
+            col_attrs[:totalsRowDxfId] = col[:totals_row_dxf_id].to_s if col[:totals_row_dxf_id]
+            col_attrs[:headerRowDxfId] = col[:header_row_dxf_id].to_s if col[:header_row_dxf_id]
+            col_attrs[:dataCellStyle] = col[:data_cell_style].to_s if col[:data_cell_style]
+          end
+          if calc_formula || tot_formula
+            b.open_tag("tableColumn", col_attrs)
+            b.tag("calculatedColumnFormula") { |cb| cb.text(calc_formula.to_s) } if calc_formula
+            b.tag("totalsRowFormula") { |tb| tb.text(tot_formula.to_s) } if tot_formula
+            b.close_tag("tableColumn")
+          else
+            b.empty_tag("tableColumn", col_attrs)
+          end
         end
         b.close_tag("tableColumns")
 
@@ -1124,6 +1453,62 @@ module Xlsxrb
         b.close_tag("Properties")
         io.string
       end
+
+      def resolve_active_tab_index
+        active_tab = @workbook_properties&.[](:active_tab)
+        if active_tab.nil?
+          first_vis_idx = @sheets.find_index do |s|
+            state = s.respond_to?(:state) ? s.state : s[:state]
+            state.nil? || state.to_sym == :visible
+          end
+          active_tab = first_vis_idx if first_vis_idx&.positive?
+        end
+
+        if active_tab.is_a?(String) || active_tab.is_a?(Symbol)
+          target_name = active_tab.to_s
+          idx = @sheets.find_index do |s|
+            (s.respond_to?(:name) ? s.name : s[:name]) == target_name
+          end
+          raise ArgumentError, "Active sheet '#{target_name}' not found" if idx.nil?
+
+          active_tab = idx
+        end
+
+        if active_tab
+          target_sheet = @sheets[active_tab]
+          raise ArgumentError, "Active sheet index #{active_tab} out of bounds" if target_sheet.nil?
+
+          state = target_sheet.respond_to?(:state) ? target_sheet.state : target_sheet[:state]
+          if state && state.to_sym != :visible
+            name = target_sheet.respond_to?(:name) ? target_sheet.name : target_sheet[:name]
+            raise ArgumentError, "Cannot set hidden sheet '#{name}' as active sheet"
+          end
+        end
+
+        active_tab
+      end
+
+      def resolve_first_sheet_index
+        first_sheet = @workbook_properties&.[](:first_sheet)
+        return nil if first_sheet.nil?
+
+        if first_sheet.is_a?(String) || first_sheet.is_a?(Symbol)
+          target_name = first_sheet.to_s
+          idx = @sheets.find_index do |s|
+            (s.respond_to?(:name) ? s.name : s[:name]) == target_name
+          end
+          raise ArgumentError, "First sheet '#{target_name}' not found" if idx.nil?
+
+          first_sheet = idx
+        end
+
+        if first_sheet
+          target_sheet = @sheets[first_sheet]
+          raise ArgumentError, "First sheet index #{first_sheet} out of bounds" if target_sheet.nil?
+        end
+
+        first_sheet
+      end
     end
   end
 end