xlsxrb 0.1.16 → 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,11 +608,23 @@ module Xlsxrb
           b.empty_tag("workbookProtection", wp_attrs) unless wp_attrs.empty?
         end
 
-        # Workbook view: which sheet tab is selected when the file is opened
-        active_tab = @workbook_properties&.[](:active_tab)
-        if active_tab
+        # 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", { activeTab: active_tab.to_s })
+          b.empty_tag("workbookView", bv_attrs)
           b.close_tag("bookViews")
         end
 
@@ -597,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
@@ -650,12 +783,28 @@ 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 == [{}]
               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
@@ -834,22 +983,7 @@ 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)
@@ -867,22 +1001,34 @@ module Xlsxrb
             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
+          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_attrs = {}
-          pattern_attrs[:patternType] = fill[:pattern] if fill[:pattern]
+          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_attrs = color_tag_attrs(fill[:fg_color])
+            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
@@ -1028,14 +1174,22 @@ 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]
+                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(" ")
@@ -1067,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(
@@ -1112,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,
@@ -1128,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
 
@@ -1150,8 +1309,8 @@ 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] || []
@@ -1159,18 +1318,23 @@ module Xlsxrb
         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)
-            col_attrs[:totalsRowFunction] = col[:totals_row_function].to_s if col[:totals_row_function]
+            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 col.is_a?(Hash) && (col[:calculated_column_formula] || col[:totals_row_formula])
+          if calc_formula || tot_formula
             b.open_tag("tableColumn", col_attrs)
-            b.tag("calculatedColumnFormula") { |cb| cb.text(col[:calculated_column_formula].to_s) } if col[:calculated_column_formula]
-            b.tag("totalsRowFormula") { |tb| tb.text(col[:totals_row_formula].to_s) } if col[:totals_row_formula]
+            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)
@@ -1289,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

data/lib/xlsxrb/ooxml/worksheet_parser.rb

@@ -201,6 +201,7 @@ module Xlsxrb
 
         pos = sd_open_end + 1
         last_row_index = -1
+        shared_masters = {}
 
         while pos < sd_end
           row_start = xml.index(row_start_pattern, pos)
@@ -245,7 +246,7 @@ module Xlsxrb
           row_end = xml.index(row_end_tag, tag_end + 1)
           break unless row_end
 
-          fast_scan_cells_events(xml, tag_end + 1, row_end, shared_strings, row_source, prefix, &block)
+          fast_scan_cells_events(xml, tag_end + 1, row_end, shared_strings, row_source, prefix, shared_masters, &block)
 
           block.call(Event.new(
                        type: :row_end,
@@ -314,7 +315,7 @@ module Xlsxrb
 
       private_class_method :tag_attr
 
-      def self.fast_scan_cells_events(xml, from, to, shared_strings, row_source, prefix = "", &block)
+      def self.fast_scan_cells_events(xml, from, to, shared_strings, row_source, prefix = "", shared_masters = {}, &block)
         pos = from
         c_start_pattern = "<#{prefix}c"
         c_start_len = c_start_pattern.bytesize
@@ -393,13 +394,26 @@ module Xlsxrb
             elsif xml.byteslice(tag_pos, f_tag_start_str.bytesize) == f_tag_start_str
               f_tag_end = xml.index(">", tag_pos + f_tag_start_str.bytesize)
               if f_tag_end && f_tag_end < c_end
+                f_tag_slice = xml.byteslice(tag_pos, f_tag_end - tag_pos)
+                is_shared = f_tag_slice.include?('t="shared"') || f_tag_slice.include?("t='shared'")
+                si = is_shared ? tag_attr(f_tag_slice, ' si="') : nil
                 if xml.getbyte(f_tag_end - 1) == 47 # self-closing <f ... />
+                  if si && (master = shared_masters[si])
+                    formula = Xlsxrb::Utils.expand_formula(master[:formula], from_ref: master[:ref], to_ref: ref)
+                  end
                   cpos = f_tag_end + 1
                 else
                   f_end = xml.index(f_tag_end_str, f_tag_end + 1)
                   if f_end && f_end <= c_end
                     formula = xml.byteslice(f_tag_end + 1, f_end - f_tag_end - 1).force_encoding("UTF-8")
                     formula = decode_xml_entities(formula) if formula.include?("&")
+                    if is_shared && si
+                      if formula && !formula.empty?
+                        shared_masters[si] = { ref: ref, formula: formula }
+                      elsif (master = shared_masters[si])
+                        formula = Xlsxrb::Utils.expand_formula(master[:formula], from_ref: master[:ref], to_ref: ref)
+                      end
+                    end
                     cpos = f_end + f_tag_end_len
                   else
                     cpos = f_tag_end + 1
@@ -598,8 +612,8 @@ module Xlsxrb
               min: attrs["min"]&.to_i,
               max: attrs["max"]&.to_i,
               width: attrs["width"]&.to_f,
-              hidden: attrs["hidden"] == "1",
-              custom_width: attrs["customWidth"] == "1",
+              hidden: attrs["hidden"] == "1" || (attrs["hidden"]&.casecmp?("true") || false),
+              custom_width: attrs["customWidth"] == "1" || (attrs["customWidth"]&.casecmp?("true") || false),
               outline_level: attrs["outlineLevel"]&.to_i,
               style_index: attrs["style"]&.to_i
             }