xlsxrb 0.1.4 → 0.1.5

data/lib/xlsxrb/ooxml/xml_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module Xlsxrb
   module Ooxml
     # Streams well-formed XML to a writable IO without building a DOM.

data/lib/xlsxrb/ooxml/xml_parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "rexml/parsers/sax2parser"
 require "rexml/sax2listener"
 

data/lib/xlsxrb/ooxml/zip_generator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "zlib"
 
 module Xlsxrb
@@ -142,20 +144,15 @@ module Xlsxrb
       end
 
       def le16(value)
-        [(value & 0xFF), ((value >> 8) & 0xFF)]
+        [value].pack("v").bytes
       end
 
       def le32(value)
-        [(value & 0xFF), ((value >> 8) & 0xFF), ((value >> 16) & 0xFF), ((value >> 24) & 0xFF)]
+        [value].pack("V").bytes
       end
 
       def calculate_central_dir_size
-        size = 0
-        @entries.each do |entry|
-          filename = entry[:path]
-          size += 46 + filename.bytesize
-        end
-        size
+        @entries.sum { |entry| 46 + entry[:path].bytesize }
       end
     end
   end

data/lib/xlsxrb/ooxml/zip_reader.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "zlib"
 require "stringio"
+require "tempfile"
 
 module Xlsxrb
   module Ooxml
     # Reads ZIP archives using only stdlib (zlib).
     # Scans local file headers sequentially — works with non-seekable IO.
     class ZipReader
-      LOCAL_HEADER_SIG = [0x50, 0x4B, 0x03, 0x04].pack("C4")
+      LOCAL_HEADER_SIG = "PK\x03\x04".b
+      MAX_UNCOMPRESSED_SIZE = 500 * 1024 * 1024 # 500MB per file limit
 
       # Opens a ZIP from a file path or IO and yields the reader.
       def self.open(source)
@@ -57,85 +61,94 @@ module Xlsxrb
 
       def parse_entries
         result = {}
-        data = @io.is_a?(StringIO) ? @io.string : @io.read
-        data = data.b
-        pos = 0
 
-        while pos + 4 <= data.bytesize
-          sig = data[pos, 4]
+        io = if @io.is_a?(StringIO) || (@io.respond_to?(:read) && @io.respond_to?(:seek) && @io.respond_to?(:pos))
+               @io
+             elsif @io.respond_to?(:each) || @io.is_a?(Enumerator)
+               tf = Tempfile.new("xlsxrb_zip")
+               tf.binmode
+               @io.each { |chunk| tf.write(chunk) }
+               tf.rewind
+               tf
+             else
+               StringIO.new(@io.read.b)
+             end
+
+        io.binmode if io.respond_to?(:binmode)
+
+        first_sig = io.read(4)
+        raise ArgumentError, "Invalid magic number: Expected a valid ZIP/XLSX file format (PK\\x03\\x04)" unless first_sig == LOCAL_HEADER_SIG
+
+        io.seek(-4, IO::SEEK_CUR) if io.respond_to?(:seek)
+        io = StringIO.new(first_sig + io.read.b) unless io.respond_to?(:seek)
+
+        loop do
+          sig = io.read(4)
           break unless sig == LOCAL_HEADER_SIG
 
-          # Local file header: 4 sig + 2 version + 2 flags + 2 method + 2 time + 2 date
-          #   + 4 crc + 4 compressed + 4 uncompressed + 2 name_len + 2 extra_len = 30 bytes
-          break if pos + 30 > data.bytesize
+          header = io.read(26)
+          break unless header && header.bytesize == 26
 
-          gp_flag        = data[pos + 6, 2].unpack1("v")
-          method         = data[pos + 8, 2].unpack1("v")
-          data[pos + 14, 4].unpack1("V")
-          compressed_size = data[pos + 18, 4].unpack1("V")
-          data[pos + 22, 4].unpack1("V")
-          name_len       = data[pos + 26, 2].unpack1("v")
-          extra_len      = data[pos + 28, 2].unpack1("v")
+          gp_flag         = header[2, 2].unpack1("v")
+          method          = header[4, 2].unpack1("v")
+          compressed_size = header[14, 4].unpack1("V")
+          name_len        = header[22, 2].unpack1("v")
+          extra_len       = header[24, 2].unpack1("v")
 
-          entry_name = data[pos + 30, name_len].force_encoding("UTF-8")
-          file_data_offset = pos + 30 + name_len + extra_len
+          entry_name = io.read(name_len).force_encoding("UTF-8")
+          io.read(extra_len) # skip extra
 
-          # Data descriptor present if bit 3 of gp_flag is set
           has_data_descriptor = gp_flag.anybits?(0x08)
 
           if has_data_descriptor && compressed_size.zero?
-            # Need to find the data descriptor to know sizes
-            raw, comp_sz, = find_data_descriptor(data, file_data_offset, method)
-            entry_data = decompress(raw, method)
-            result[entry_name] = entry_data unless entry_name.end_with?("/")
-            # Skip past data + descriptor (12 or 16 bytes)
-            desc_offset = file_data_offset + comp_sz
-            # Check for optional signature
-            pos = if desc_offset + 4 <= data.bytesize && data[desc_offset, 4] == [0x50, 0x4B, 0x07, 0x08].pack("C4")
-                    desc_offset + 16
-                  else
-                    desc_offset + 12
-                  end
+            raw, = find_data_descriptor_stream(io, method)
           else
-            raw = data[file_data_offset, compressed_size]
-            entry_data = decompress(raw, method)
-            result[entry_name] = entry_data unless entry_name.end_with?("/")
-            pos = file_data_offset + compressed_size
+            raw = io.read(compressed_size)
           end
+          entry_data = decompress(raw, method)
+          result[entry_name] = entry_data unless entry_name.end_with?("/")
+        end
+
+        if io.is_a?(Tempfile)
+          io.close
+          io.unlink
         end
 
         result
       end
 
-      def find_data_descriptor(data, offset, method)
-        # For deflated data, we inflate to find the end
+      def find_data_descriptor_stream(io, method)
         if method == 8
           inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
           result = +""
           consumed = 0
           chunk_size = 4096
-          pos = offset
           begin
-            while pos < data.bytesize
-              chunk = data[pos, [chunk_size, data.bytesize - pos].min]
-              break if chunk.nil? || chunk.empty?
+            while (chunk = io.read(chunk_size))
+              break if chunk.empty?
 
-              result << inflater.inflate(chunk)
+              inflated = inflater.inflate(chunk)
+              raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{MAX_UNCOMPRESSED_SIZE} bytes" if result.bytesize + inflated.bytesize > MAX_UNCOMPRESSED_SIZE
+
+              result << inflated
               consumed += chunk.bytesize
-              pos += chunk.bytesize
             end
           rescue Zlib::BufError, Zlib::DataError
-            # Inflation ended — find actual consumed size
+            # Inflation ended
           ensure
-            # Calculate actual compressed bytes consumed
             consumed -= inflater.avail_in
             inflater.close
           end
-          [result, consumed, result.bytesize]
+
+          io.seek(-inflater.avail_in, IO::SEEK_CUR) if io.respond_to?(:seek)
+
+          desc_sig = io.read(4)
+          io.seek(-4, IO::SEEK_CUR) unless desc_sig == [0x50, 0x4B, 0x07, 0x08].pack("C4")
+          io.read(12)
+
+          [result, consumed]
         else
-          # Stored — scan for data descriptor signature or central directory
-          # This is a fallback; stored + data descriptor is rare
-          [data[offset, 0], 0, 0]
+          [io.read(0), 0]
         end
       end
 
@@ -143,15 +156,38 @@ module Xlsxrb
         return raw&.dup&.force_encoding("UTF-8") || "" if method.zero? # stored
 
         # Deflated
-        Zlib::Inflate.inflate(-raw || "")
+        safe_inflate(raw || "", -Zlib::MAX_WBITS)
       rescue Zlib::DataError
         # Try with raw deflate (no header)
-        inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+        safe_inflate(raw || "", -Zlib::MAX_WBITS)
+      end
+
+      def safe_inflate(raw, wbits)
+        inflater = Zlib::Inflate.new(wbits)
+        result = +""
+        chunk_size = 32_768
+        offset = 0
+        raw_len = raw.bytesize
+
         begin
-          inflater.inflate(raw || "")
+          while offset < raw_len
+            chunk = raw.byteslice(offset, chunk_size)
+            inflated = inflater.inflate(chunk)
+            raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{MAX_UNCOMPRESSED_SIZE} bytes" if result.bytesize + inflated.bytesize > MAX_UNCOMPRESSED_SIZE
+
+            result << inflated
+            offset += chunk_size
+          end
+          # Finish inflation
+          inflated = inflater.finish
+          raise ArgumentError, "ZIP bomb detected: Uncompressed size exceeds #{MAX_UNCOMPRESSED_SIZE} bytes" if result.bytesize + inflated.bytesize > MAX_UNCOMPRESSED_SIZE
+
+          result << inflated
         ensure
           inflater.close
         end
+
+        result.force_encoding("UTF-8")
       end
     end
   end

data/lib/xlsxrb/ooxml/zip_writer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require "zlib"
 
 module Xlsxrb

data/lib/xlsxrb/ooxml.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 require_relative "ooxml/utils"
 require_relative "ooxml/zip_reader"
 require_relative "ooxml/zip_writer"
@@ -17,6 +19,6 @@ module Xlsxrb
   # Handles ZIP extraction, SAX XML parsing, and XML generation
   # in strict accordance with ECMA-376.
   module Ooxml
-    Event = Struct.new(:type, :args, :source)
+    Event = Data.define(:type, :args, :source)
   end
 end

data/lib/xlsxrb/style_builder.rb

@@ -1,9 +1,35 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module Xlsxrb
   # Helper class for building cell styles with a fluent DSL.
   # Encapsulates font, fill, border, alignment, and number format properties.
   class StyleBuilder
+    COLORS = {
+      black: "FF000000",
+      white: "FFFFFFFF",
+      red: "FFFF0000",
+      green: "FF00FF00",
+      blue: "FF0000FF",
+      yellow: "FFFFFF00",
+      cyan: "FF00FFFF",
+      magenta: "FFFF00FF",
+      gray: "FF808080",
+      grey: "FF808080"
+    }.freeze
+
+    def resolve_color(color)
+      return nil unless color
+
+      if color.is_a?(Symbol) || (color.is_a?(String) && color.start_with?(":") && color.length > 1)
+        key = color.to_s.sub(/^:/, "").to_sym
+        return COLORS[key] || color.to_s
+      end
+      color.to_s
+    end
+
+    # : (?String? name) -> void
     def initialize(name = nil)
       @name = name
       @font_props = {}
@@ -17,83 +43,149 @@ module Xlsxrb
 
     # Applies option-style definitions so callers can use add_style(name, **opts)
     # as an alternative to block-based fluent chaining.
+    # : (**untyped opts) -> self
     def apply_options!(**opts)
-      bold(opts[:bold]) if opts.key?(:bold)
-      italic(opts[:italic]) if opts.key?(:italic)
-      size(opts[:size]) if opts.key?(:size)
-      font_name(opts[:font_name]) if opts.key?(:font_name)
-      font_color(opts[:font_color]) if opts.key?(:font_color)
-      underline(opts[:underline]) if opts.key?(:underline)
-      strike(opts[:strike]) if opts.key?(:strike)
-      vert_align(opts[:vert_align]) if opts.key?(:vert_align)
+      if opts.key?(:font)
+        font_opts = opts[:font] || {}
+        bold(font_opts[:bold]) if font_opts.key?(:bold)
+        italic(font_opts[:italic]) if font_opts.key?(:italic)
+        size(font_opts[:size]) if font_opts.key?(:size)
+        font_name(font_opts[:name]) if font_opts.key?(:name)
+        font_color(font_opts[:color]) if font_opts.key?(:color)
+        underline(font_opts[:underline]) if font_opts.key?(:underline)
+        strike(font_opts[:strike]) if font_opts.key?(:strike)
+        vert_align(font_opts[:vert_align]) if font_opts.key?(:vert_align)
+      else
+        bold(opts[:bold]) if opts.key?(:bold)
+        italic(opts[:italic]) if opts.key?(:italic)
+        size(opts[:size]) if opts.key?(:size)
+        font_name(opts[:font_name]) if opts.key?(:font_name)
+        font_color(opts[:font_color]) if opts.key?(:font_color)
+        underline(opts[:underline]) if opts.key?(:underline)
+        strike(opts[:strike]) if opts.key?(:strike)
+        vert_align(opts[:vert_align]) if opts.key?(:vert_align)
+      end
 
-      fill_color(opts[:fill_color]) if opts.key?(:fill_color)
-      if opts.key?(:fill_pattern)
-        pattern = opts[:fill_pattern] || {}
-        fill_pattern(
-          pattern[:pattern] || "solid",
-          fg_color: pattern[:fg_color],
-          bg_color: pattern[:bg_color]
-        )
+      if opts.key?(:fill)
+        fill_opts = opts[:fill] || {}
+        if fill_opts.key?(:color)
+          fill_color(fill_opts[:color])
+        else
+          fill_pattern(
+            fill_opts[:pattern] || "solid",
+            fg_color: fill_opts[:fg_color],
+            bg_color: fill_opts[:bg_color]
+          )
+        end
+      else
+        fill_color(opts[:fill_color]) if opts.key?(:fill_color)
+        if opts.key?(:fill_pattern)
+          pattern = opts[:fill_pattern] || {}
+          fill_pattern(
+            pattern[:pattern] || "solid",
+            fg_color: pattern[:fg_color],
+            bg_color: pattern[:bg_color]
+          )
+        end
       end
       fill_gradient(**opts[:fill_gradient]) if opts.key?(:fill_gradient) && opts[:fill_gradient]
 
-      border_all(**opts[:border_all]) if opts.key?(:border_all) && opts[:border_all]
-      border_left(**opts[:border_left]) if opts.key?(:border_left) && opts[:border_left]
-      border_right(**opts[:border_right]) if opts.key?(:border_right) && opts[:border_right]
-      border_top(**opts[:border_top]) if opts.key?(:border_top) && opts[:border_top]
-      border_bottom(**opts[:border_bottom]) if opts.key?(:border_bottom) && opts[:border_bottom]
+      if opts.key?(:border)
+        border_opts = opts[:border] || {}
+        border_all(**border_opts[:all]) if border_opts.key?(:all) && border_opts[:all]
+        border_left(**border_opts[:left]) if border_opts.key?(:left) && border_opts[:left]
+        border_right(**border_opts[:right]) if border_opts.key?(:right) && border_opts[:right]
+        border_top(**border_opts[:top]) if border_opts.key?(:top) && border_opts[:top]
+        border_bottom(**border_opts[:bottom]) if border_opts.key?(:bottom) && border_opts[:bottom]
+      else
+        border_all(**opts[:border_all]) if opts.key?(:border_all) && opts[:border_all]
+        border_left(**opts[:border_left]) if opts.key?(:border_left) && opts[:border_left]
+        border_right(**opts[:border_right]) if opts.key?(:border_right) && opts[:border_right]
+        border_top(**opts[:border_top]) if opts.key?(:border_top) && opts[:border_top]
+        border_bottom(**opts[:border_bottom]) if opts.key?(:border_bottom) && opts[:border_bottom]
+      end
 
       number_format(opts[:number_format]) if opts.key?(:number_format)
 
-      align_horizontal(opts[:align_horizontal]) if opts.key?(:align_horizontal)
-      align_vertical(opts[:align_vertical]) if opts.key?(:align_vertical)
-      wrap_text(opts[:wrap_text]) if opts.key?(:wrap_text)
-      text_rotation(opts[:text_rotation]) if opts.key?(:text_rotation)
-      indent(opts[:indent]) if opts.key?(:indent)
-      shrink_to_fit(opts[:shrink_to_fit]) if opts.key?(:shrink_to_fit)
+      if opts.key?(:alignment)
+        align_opts = opts[:alignment] || {}
+        align_horizontal(align_opts[:horizontal]) if align_opts.key?(:horizontal)
+        align_vertical(align_opts[:vertical]) if align_opts.key?(:vertical)
+        wrap_text(align_opts[:wrap_text]) if align_opts.key?(:wrap_text)
+        text_rotation(align_opts[:text_rotation]) if align_opts.key?(:text_rotation)
+        indent(align_opts[:indent]) if align_opts.key?(:indent)
+        shrink_to_fit(align_opts[:shrink_to_fit]) if align_opts.key?(:shrink_to_fit)
+      else
+        align_horizontal(opts[:align_horizontal]) if opts.key?(:align_horizontal)
+        align_vertical(opts[:align_vertical]) if opts.key?(:align_vertical)
+        wrap_text(opts[:wrap_text]) if opts.key?(:wrap_text)
+        text_rotation(opts[:text_rotation]) if opts.key?(:text_rotation)
+        indent(opts[:indent]) if opts.key?(:indent)
+        shrink_to_fit(opts[:shrink_to_fit]) if opts.key?(:shrink_to_fit)
+      end
 
       self
     end
 
     # --- Font Properties ---
 
+    # : (**untyped opts) -> self
+    def font(**opts)
+      bold(opts[:bold]) if opts.key?(:bold)
+      italic(opts[:italic]) if opts.key?(:italic)
+      size(opts[:size]) if opts.key?(:size)
+      font_name(opts[:name]) if opts.key?(:name)
+      font_color(opts[:color]) if opts.key?(:color)
+      underline(opts[:underline]) if opts.key?(:underline)
+      strike(opts[:strike]) if opts.key?(:strike)
+      vert_align(opts[:vert_align]) if opts.key?(:vert_align)
+      self
+    end
+
     # rubocop:disable Style/OptionalBooleanParameter
+    # : (?bool value) -> self
     def bold(value = true)
       @font_props[:bold] = value
       self
     end
 
+    # : (?bool value) -> self
     def italic(value = true)
       @font_props[:italic] = value
       self
     end
 
+    # : (Numeric size_value) -> self
     def size(size_value)
       @font_props[:sz] = size_value.to_i
       self
     end
 
+    # : (String name) -> self
     def font_name(name)
       @font_props[:name] = name
       self
     end
 
+    # : (String | Symbol color) -> self
     def font_color(color)
-      @font_props[:color] = color
+      @font_props[:color] = resolve_color(color)
       self
     end
 
+    # : (?String val) -> self
     def underline(val = "single")
       @font_props[:underline] = val
       self
     end
 
+    # : (?bool value) -> self
     def strike(value = true)
       @font_props[:strike] = value
       self
     end
 
+    # : (String value) -> self
     def vert_align(value)
       @font_props[:vert_align] = value
       self
@@ -102,6 +194,7 @@ module Xlsxrb
 
     # --- Fill Properties ---
 
+    # : (String | Symbol pattern, ?fg_color: String | Symbol | nil, ?bg_color: String | Symbol | nil) -> self
     def fill_pattern(pattern, fg_color: nil, bg_color: nil)
       @fill_props[:pattern] = pattern
       @fill_props[:fg_color] = fg_color if fg_color
@@ -109,16 +202,19 @@ module Xlsxrb
       self
     end
 
+    # : (String | Symbol color) -> self
     def fill_color(color)
       @fill_props[:pattern] = "solid"
-      @fill_props[:fg_color] = color
+      @fill_props[:fg_color] = resolve_color(color)
       self
     end
 
+    # : (?pattern: String | Symbol, ?fg_color: String | Symbol | nil, ?bg_color: String | Symbol | nil) -> self
     def fill(pattern: "solid", fg_color: nil, bg_color: nil)
-      fill_pattern(pattern, fg_color: fg_color, bg_color: bg_color)
+      fill_pattern(pattern, fg_color: resolve_color(fg_color), bg_color: resolve_color(bg_color))
     end
 
+    # : (type: String, ?degree: Numeric | nil, ?stops: Array[untyped]) -> self
     def fill_gradient(type:, degree: nil, stops: [])
       @fill_props[:gradient] = {
         type: type,
@@ -130,8 +226,19 @@ module Xlsxrb
 
     # --- Border Properties ---
 
+    # : (**untyped opts) -> self
+    def border(**opts)
+      border_all(**opts[:all]) if opts.key?(:all) && opts[:all]
+      border_left(**opts[:left]) if opts.key?(:left) && opts[:left]
+      border_right(**opts[:right]) if opts.key?(:right) && opts[:right]
+      border_top(**opts[:top]) if opts.key?(:top) && opts[:top]
+      border_bottom(**opts[:bottom]) if opts.key?(:bottom) && opts[:bottom]
+      self
+    end
+
+    # : (?style: String | Symbol, ?color: String | Symbol | nil) -> self
     def border_all(style: "thin", color: nil)
-      color_opt = color ? { color: color } : {}
+      color_opt = color ? { color: resolve_color(color) } : {}
       @border_props[:left] = { style: style, **color_opt }
       @border_props[:right] = { style: style, **color_opt }
       @border_props[:top] = { style: style, **color_opt }
@@ -139,29 +246,34 @@ module Xlsxrb
       self
     end
 
+    # : (?style: String | Symbol, ?color: String | Symbol | nil) -> self
     def border_left(style: "thin", color: nil)
-      @border_props[:left] = { style: style, color: color }.compact
+      @border_props[:left] = { style: style, color: resolve_color(color) }.compact
       self
     end
 
+    # : (?style: String | Symbol, ?color: String | Symbol | nil) -> self
     def border_right(style: "thin", color: nil)
-      @border_props[:right] = { style: style, color: color }.compact
+      @border_props[:right] = { style: style, color: resolve_color(color) }.compact
       self
     end
 
+    # : (?style: String | Symbol, ?color: String | Symbol | nil) -> self
     def border_top(style: "thin", color: nil)
-      @border_props[:top] = { style: style, color: color }.compact
+      @border_props[:top] = { style: style, color: resolve_color(color) }.compact
       self
     end
 
+    # : (?style: String | Symbol, ?color: String | Symbol | nil) -> self
     def border_bottom(style: "thin", color: nil)
-      @border_props[:bottom] = { style: style, color: color }.compact
+      @border_props[:bottom] = { style: style, color: resolve_color(color) }.compact
       self
     end
 
     # rubocop:disable Naming/MethodParameterName
+    # : (?style: String | Symbol, ?color: String | Symbol | nil, ?up: bool, ?down: bool) -> self
     def border_diagonal(style: "thin", color: nil, up: false, down: false)
-      @border_props[:diagonal] = { style: style, color: color }.compact
+      @border_props[:diagonal] = { style: style, color: resolve_color(color) }.compact
       @border_props[:diagonal_up] = true if up
       @border_props[:diagonal_down] = true if down
       self
@@ -170,33 +282,39 @@ module Xlsxrb
 
     # --- Alignment Properties ---
 
+    # : (String | Symbol value) -> self
     def align_horizontal(value)
       @alignment[:horizontal] = value
       self
     end
 
+    # : (String | Symbol value) -> self
     def align_vertical(value)
       @alignment[:vertical] = value
       self
     end
 
     # rubocop:disable Style/OptionalBooleanParameter
+    # : (?bool value) -> self
     def wrap_text(value = true)
       @alignment[:wrap_text] = value
       self
     end
 
+    # : (?bool value) -> self
     def shrink_to_fit(value = true)
       @alignment[:shrink_to_fit] = value
       self
     end
     # rubocop:enable Style/OptionalBooleanParameter
 
+    # : (Numeric value) -> self
     def text_rotation(value)
       @alignment[:text_rotation] = value
       self
     end
 
+    # : (Numeric value) -> self
     def indent(value)
       @alignment[:indent] = value.to_i
       self
@@ -204,6 +322,7 @@ module Xlsxrb
 
     # --- Number Format ---
 
+    # : (String | Integer num_fmt_id) -> self
     def number_format(num_fmt_id)
       @num_fmt_id = num_fmt_id
       self
@@ -212,6 +331,7 @@ module Xlsxrb
 
     # Register this style with the given Writer, returning the style_id.
     # writer:: Xlsxrb::Ooxml::Writer instance
+    # : (untyped writer) -> Integer
     def register_with(writer)
       font_id = 0
       fill_id = 0

data/lib/xlsxrb/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rbs_inline: enabled
+
 module Xlsxrb
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end