zaxcel 0.1.1

data/lib/zaxcel/document.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Document
+  extend T::Sig
+
+  MAX_SHEET_NAME_LENGTH = 31
+  DEFAULT_WIDTH_UNITS_BY_DEFAULT_CHARACTER = 0.85 # empirically determined for 11pt body Calibri
+
+  sig { returns(Float) }
+  attr_reader :width_units_by_default_character
+
+  sig { params(width_units_by_default_character: Float).void }
+  def initialize(width_units_by_default_character: DEFAULT_WIDTH_UNITS_BY_DEFAULT_CHARACTER)
+    @document = T.let(Axlsx::Package.new, Axlsx::Package)
+    @document.workbook.escape_formulas = false
+    @width_units_by_default_character = width_units_by_default_character
+  end
+
+  sig { params(sheet: Axlsx::Worksheet, range_to_include: String).void }
+  def set_print_area(sheet:, range_to_include:)
+    @document.workbook.add_defined_name(range_to_include.to_s, local_sheet_id: sheet.index, name: '_xlnm.Print_Area')
+  end
+
+  sig { params(sheet_name: String, sheet_visibility: Zaxcel::Sheet::SheetVisibility).returns(Zaxcel::Sheet) }
+  def add_sheet!(sheet_name, sheet_visibility: Zaxcel::Sheet::SheetVisibility::Visible)
+    clean_sheet_name = clean_sheet_name(sheet_name)
+
+    worksheet = @document.workbook.add_worksheet({ name: clean_sheet_name })
+    worksheet.page_setup.fit_to(width: 1, height: 1)
+
+    # This is necessary to show grouped columns, etc. The default value is false, which is inconsistent with new
+    # new documents created in excel. See https://github.com/caxlsx/caxlsx/issues/344 for additional context.
+    worksheet.sheet_view.show_outline_symbols = true
+
+    sheet = Zaxcel::Sheet.new(name: sheet_name, document: self, worksheet: worksheet, visibility: sheet_visibility)
+    sheet_by_name[sheet_name] = sheet
+
+    sheet
+  end
+
+  sig { params(name: Symbol).returns(T.nilable(Integer)) }
+  def style(name)
+    styles_by_style_name[name]
+  end
+
+  sig { params(name: Symbol, kwargs: T.untyped).returns(Integer) }
+  def add_style!(name, **kwargs)
+    styles_by_style_name[name] ||= @document.workbook.styles.add_style(**kwargs)
+  end
+
+  sig { returns(T::Hash[Symbol, Integer]) }
+  def styles_by_style_name
+    @styles ||= T.let({}, T.nilable(T::Hash[Symbol, Integer]))
+  end
+
+  sig { params(name: String).returns(T.nilable(Zaxcel::Sheet)) }
+  def sheet(name)
+    sheet_by_name[name]
+  end
+
+  sig { returns(T::Hash[String, Zaxcel::Sheet]) }
+  def sheet_by_name
+    @sheet_by_name ||= T.let({}, T.nilable(T::Hash[String, Zaxcel::Sheet]))
+  end
+
+  sig { returns(T.nilable(String)) }
+  def file_contents
+    stream = T.cast(@document.to_stream, T.any(StringIO, T::Boolean))
+    return if !stream.is_a?(StringIO)
+
+    stream.read
+  end
+
+  # this exposes the underlying axlsx document directly. it's an escape hatch for modifying the document in ways not
+  # directly supported by zaxcel. it is unsafe in that it can break zaxcel's assumptions about the document leading to
+  # unintended consequences. use with caution.
+  sig { returns(Axlsx::Package) }
+  def unsafe_axlsx_document
+    @document
+  end
+
+  sig { params(sheet_name: String, pending_sheet_names: T::Array[String]).returns(String) }
+  def clean_sheet_name(sheet_name, pending_sheet_names: [])
+    # sheet names in excel must
+    # 1. be max 31 charaters
+    # 2. not special characters
+    # 3. be unique
+    cleaned_sheet_name = sheet_name.gsub(/[^0-9a-z_ ]/i, '').parameterize(
+      separator: ' ',
+      preserve_case: true,
+    ).first(MAX_SHEET_NAME_LENGTH)
+
+    unique_index = 0
+
+    unique_name = cleaned_sheet_name
+    while @document.workbook.sheet_by_name(unique_name).present? || pending_sheet_names.include?(unique_name)
+      unique_index += 1
+      unique_name = "#{cleaned_sheet_name.first(cleaned_sheet_name.length - unique_index.to_s.length)}#{unique_index}"
+    end
+
+    unique_name
+  end
+
+  class << self
+    extend T::Sig
+
+    sig { params(start_reference: Zaxcel::References::Cell, end_reference: Zaxcel::References::Cell).returns(T::Array[Zaxcel::Cell]) }
+    def cells_in_range(start_reference:, end_reference:)
+      cell_start = T.must(start_reference.cell)
+      cell_end = T.must(end_reference.cell)
+
+      if cell_start.column == cell_end.column
+        column = cell_start.column
+
+        cells_in_column = column.cell_by_row_name.values
+        cells_in_column.select do |cell|
+          row_position = T.must(cell.row_position)
+
+          row_position >= T.must(cell_start.row_position) && row_position <= T.must(cell_end.row_position)
+        end
+      elsif cell_start.row == cell_end.row
+        row = cell_start.row
+
+        cells_in_row = row.cell_by_column_name.values
+        cells_in_row.select do |cell|
+          col_position = T.must(cell.col_position)
+
+          col_position >= T.must(cell_start.col_position) && col_position <= T.must(cell_end.col_position)
+        end
+      else
+        raise 'Cells must be in the same row or column in order to sum'
+      end
+    end
+  end
+end

data/lib/zaxcel/function.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Functions don't have any special interface beyond cell formulas, but it's useful to be able to detect them since they
+# interact with other cell formulas in their own way.
+class Zaxcel::Function < Zaxcel::CellFormula; end

data/lib/zaxcel/functions/abs.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Abs < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(value: Zaxcel::Cell::ValueType).void }
+  def initialize(value)
+    @value = value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_value = Zaxcel::Cell.format(@value, on_sheet: on_sheet) || 0
+
+    "ABS(#{formatted_value})"
+  end
+end

data/lib/zaxcel/functions/and.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::And < Zaxcel::Function
+  extend T::Sig
+
+  # todo - likely and can accept more than one arg, but not sure. check into this.
+  # also, it may accept only specific types of formulas (returns true or false or something), but my suspicion is that
+  # is not true. confirm this also, since right now it's typed to a strange type.
+  sig { params(left_hand_value: Zaxcel::Cell::ValueType, right_hand_value: Zaxcel::Cell::ValueType).void }
+  def initialize(left_hand_value, right_hand_value)
+    @left_hand_value = left_hand_value
+    @right_hand_value = right_hand_value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    left_hand_formatted_value = Zaxcel::Cell.format(@left_hand_value, on_sheet: on_sheet)
+    right_hand_formatted_value = Zaxcel::Cell.format(@right_hand_value, on_sheet: on_sheet)
+
+    "AND(#{left_hand_formatted_value},#{right_hand_formatted_value})"
+  end
+end

data/lib/zaxcel/functions/average.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Average < Zaxcel::Function
+  extend T::Sig
+
+  # todo - match this to the excel signature if it takes an unbounded argument array
+  sig { params(range: Zaxcel::References::Range).void }
+  def initialize(range)
+    @range = range
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "AVERAGE(#{@range.format(on_sheet: on_sheet)})"
+  end
+end

data/lib/zaxcel/functions/choose.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Choose < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(choice_index: Zaxcel::Cell::ValueType, choices: T::Array[Zaxcel::Cell::ValueType]).void }
+  def initialize(choice_index, choices:)
+    @choice_index = choice_index
+    @choices = choices
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    args = [Zaxcel::Cell.format(@choice_index, on_sheet: on_sheet)]
+    args += @choices.map { |choice| Zaxcel::Cell.format(choice, on_sheet: on_sheet) }
+
+    "CHOOSE(#{args.join(',')})"
+  end
+end

data/lib/zaxcel/functions/concatenate.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Concatenate < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(values: T::Array[Zaxcel::Cell::ValueType]).void }
+  def initialize(values)
+    @values = values
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_values = @values.map do |value|
+      Zaxcel::Cell.format(value, on_sheet: on_sheet)
+    end
+
+    "CONCATENATE(#{formatted_values.join(',')})"
+  end
+end

data/lib/zaxcel/functions/if.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::If < Zaxcel::Function
+  extend T::Sig
+
+  # access to 'clauses' can be helpful if debugging
+  sig { returns(Zaxcel::Cell::ValueType) }
+  attr_reader :condition
+
+  sig { returns(Zaxcel::Cell::ValueType) }
+  attr_reader :if_true
+
+  sig { returns(Zaxcel::Cell::ValueType) }
+  attr_reader :if_false
+
+  sig do
+    params(
+      condition: Zaxcel::Cell::ValueType,
+      if_true: Zaxcel::Cell::ValueType,
+      if_false: Zaxcel::Cell::ValueType,
+    ).void
+  end
+  def initialize(condition, if_true:, if_false:)
+    @condition = condition
+    @if_true = if_true
+    @if_false = if_false
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_condition = Zaxcel::Cell.format(@condition, on_sheet: on_sheet)
+    formatted_if_true = Zaxcel::Cell.format(@if_true, on_sheet: on_sheet)
+    formatted_if_false = Zaxcel::Cell.format(@if_false, on_sheet: on_sheet)
+
+    "IF(#{formatted_condition},#{formatted_if_true},#{formatted_if_false})"
+  end
+end

data/lib/zaxcel/functions/if_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::IfError < Zaxcel::Function
+  extend T::Sig
+
+  sig do
+    params(
+      value: Zaxcel::Cell::ValueType,
+      default_value: Zaxcel::Cell::ValueType,
+    ).void
+  end
+  def initialize(value, default_value:)
+    @value = value
+    @default_value = default_value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_value = Zaxcel::Cell.format(@value, on_sheet: on_sheet)
+    formatted_default = Zaxcel::Cell.format(@default_value, on_sheet: on_sheet)
+
+    "IFERROR(#{formatted_value},#{formatted_default})"
+  end
+end

data/lib/zaxcel/functions/index.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Index < Zaxcel::Function
+  sig do
+    params(
+      index_value: Zaxcel::Cell::ValueType,
+      range: Zaxcel::References::Range,
+    ).void
+  end
+  def initialize(index_value:, range:)
+    @index_value = index_value
+    @range = range
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "INDEX(#{@range.format(on_sheet: on_sheet)},#{Zaxcel::Cell.format(@index_value, on_sheet: on_sheet)})"
+  end
+end

data/lib/zaxcel/functions/len.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Len < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(value: Zaxcel::Cell::ValueType).void }
+  def initialize(value)
+    @value = value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "LEN(#{Zaxcel::Cell.format(@value, on_sheet: on_sheet)})"
+  end
+end

data/lib/zaxcel/functions/match/match_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Match::MatchType < T::Enum
+  enums do
+    # Finds the first value exactly equal to lookup_value. lookup_array can be in any order.
+    EXACT = new('0')
+    # Finds the largest value less than or equal to lookup_value. Requires lookup_array to be in ascending order.
+    LESS_THAN_OR_EQUAL = new('1')
+    # Finds the smallest value greater than or equal to lookup_value. Requires lookup_array to be in descending order.
+    GREATER_THAN_OR_EQUAL = new('-1')
+  end
+end

data/lib/zaxcel/functions/match.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Match < Zaxcel::Function
+  sig do
+    params(
+      value: Zaxcel::Cell::ValueType,
+      range: Zaxcel::References::Range,
+      match_type: T.nilable(Zaxcel::Functions::Match::MatchType),
+    ).void
+  end
+  def initialize(value:, range:, match_type: nil)
+    @value = value
+    @range = range
+    @match_type = match_type
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    args = [
+      Zaxcel::Cell.format(@value, on_sheet: on_sheet),
+      @range.format(on_sheet: on_sheet),
+    ]
+    args << @match_type.serialize if @match_type.present?
+    "MATCH(#{args.join(',')})"
+  end
+end

data/lib/zaxcel/functions/max.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Max < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(values: T::Array[T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)]).void }
+  def initialize(values)
+    @values = values
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_values = @values.map { |value| Zaxcel::Cell.format(value, on_sheet: on_sheet) }.compact
+    "MAX(#{formatted_values.join(',')})"
+  end
+end

data/lib/zaxcel/functions/min.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Min < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(values: T::Array[T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)]).void }
+  def initialize(values)
+    @values = values
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_values = @values.map { |value| Zaxcel::Cell.format(value, on_sheet: on_sheet) }.compact
+    "MIN(#{formatted_values.join(',')})"
+  end
+end

data/lib/zaxcel/functions/negate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: strict
+
+# This isn't really a function, it's a unary operator, so this is in the wrong spot. But I'm not sure where the best
+# place for it is yet, so just leave it here for now.
+class Zaxcel::Functions::Negate < Zaxcel::CellFormula
+  extend T::Sig
+
+  sig { params(value: Zaxcel::Cell::ValueType).void }
+  def initialize(value)
+    @value = value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_value = Zaxcel::Cell.format(@value, on_sheet: on_sheet)
+    return '0' if formatted_value.nil? && @value.is_a?(Zaxcel::References::Cell)
+
+    formatted_value = "(#{formatted_value})" if @value.is_a?(Zaxcel::BinaryExpression) && [
+      '-',
+      '+',
+    ].include?(@value.operator)
+
+    "-#{formatted_value}"
+  end
+end

data/lib/zaxcel/functions/or.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Or < Zaxcel::Function
+  extend T::Sig
+
+  # todo - likely and can accept more than one arg, but not sure. check into this.
+  # also, it may accept only specific types of formulas (returns true or false or something), but my suspicion is that
+  # is not true. confirm this also, since right now it's typed to a strange type.
+  sig { params(left_hand_value: Zaxcel::Cell::ValueType, right_hand_value: Zaxcel::Cell::ValueType).void }
+  def initialize(left_hand_value, right_hand_value)
+    @left_hand_value = left_hand_value
+    @right_hand_value = right_hand_value
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    left_hand_formatted_value = Zaxcel::Cell.format(@left_hand_value, on_sheet: on_sheet)
+    right_hand_formatted_value = Zaxcel::Cell.format(@right_hand_value, on_sheet: on_sheet)
+
+    "OR(#{left_hand_formatted_value},#{right_hand_formatted_value})"
+  end
+end

data/lib/zaxcel/functions/round.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Round < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(value: Zaxcel::Cell::ValueType, precision: Integer).void }
+  def initialize(value, precision: 0)
+    @value = value
+    @precision = precision
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_value = Zaxcel::Cell.format(@value, on_sheet: on_sheet)
+    return '0' if formatted_value.nil? && @value.is_a?(Zaxcel::References::Cell)
+
+    "ROUND(#{formatted_value},#{@precision})"
+  end
+end

data/lib/zaxcel/functions/sum.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Sum < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(values: T::Array[T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)]).void }
+  def initialize(values)
+    @values = values
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    return '0' if @values.blank?
+
+    "SUM(#{@values.map { |value| Zaxcel::Cell.format(value, on_sheet: on_sheet) }.join(',')})"
+  end
+end

data/lib/zaxcel/functions/sum_if.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::SumIf < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(range_to_check: Zaxcel::References::Range, value_to_check: Zaxcel::Cell::ValueType, range_to_sum: Zaxcel::References::Range).void }
+  def initialize(range_to_check:, value_to_check:, range_to_sum:)
+    raise 'Column to check and column to sum must be on the same sheet!' if range_to_check.sheet_name != range_to_sum.sheet_name
+
+    @range_to_check = range_to_check
+    @value_to_check = value_to_check
+    @range_to_sum = range_to_sum
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "SUMIF(#{@range_to_check.format(on_sheet: on_sheet)},#{Zaxcel::Cell.format(@value_to_check, on_sheet: on_sheet)},#{@range_to_sum.format(on_sheet: on_sheet)})"
+  end
+end

data/lib/zaxcel/functions/sum_ifs.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::SumIfs < Zaxcel::Function
+  extend T::Sig
+
+  sig do
+    params(
+      ranges_to_check: T::Array[Zaxcel::References::Range],
+      values_to_check: T::Array[Zaxcel::Cell::ValueType],
+      range_to_sum: Zaxcel::References::Range,
+    ).void
+  end
+  def initialize(ranges_to_check:, values_to_check:, range_to_sum:)
+    raise 'Columns to check and values to check must be the same length' if ranges_to_check.count != values_to_check.count
+
+    @ranges_to_check = ranges_to_check
+    @values_to_check = values_to_check
+    @range_to_sum = range_to_sum
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    criteria = @ranges_to_check.flat_map.with_index do |check_range, index|
+      check_value = @values_to_check[index]
+      [
+        check_range.format(on_sheet: on_sheet),
+        Zaxcel::Cell.format(check_value, on_sheet: on_sheet, quote_strings: false),
+      ]
+    end
+
+    "SUMIFS(#{@range_to_sum.format(on_sheet: on_sheet)},#{criteria.join(',')})"
+  end
+end

data/lib/zaxcel/functions/sum_product.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::SumProduct < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(values: T::Array[T.any(Zaxcel::Cell::ValueType, Zaxcel::References::Range)]).void }
+  def initialize(values)
+    @values = values
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    return '0' if @values.blank?
+
+    "SUMPRODUCT(#{@values.map { |value| Zaxcel::Cell.format(value, on_sheet: on_sheet) }.join(',')})"
+  end
+end

data/lib/zaxcel/functions/text.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Text < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(value: Zaxcel::Cell::ValueType, format_string: String).void }
+  def initialize(value, format_string:)
+    @value = value
+    @format_string = format_string
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "TEXT(#{Zaxcel::Cell.format(@value, on_sheet: on_sheet)},#{Zaxcel::Cell.format(@format_string, on_sheet: on_sheet)})"
+  end
+end

data/lib/zaxcel/functions/unique.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::Unique < Zaxcel::Function
+  extend T::Sig
+
+  sig { params(range: Zaxcel::References::Range, array_formula: T::Boolean).void }
+  def initialize(range, array_formula: false)
+    @range = range
+    @array_formula = array_formula
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    "UNIQUE(#{@range.format(on_sheet: on_sheet)})"
+  end
+
+  # We'll probably want to abstract this into an interface or common class or something, but for now just define here
+  sig { returns(T::Boolean) }
+  def array_formula?
+    @array_formula
+  end
+end

data/lib/zaxcel/functions/x_lookup.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# typed: strict
+
+class Zaxcel::Functions::XLookup < Zaxcel::Function
+  extend T::Sig
+
+  sig do
+    params(
+      condition: Zaxcel::Cell::ValueType,
+      idx_range: Zaxcel::References::Range,
+      value_range: Zaxcel::References::Range,
+    ).void
+  end
+  def initialize(condition, idx_range:, value_range:)
+    @condition = condition
+    @idx_range = idx_range
+    @value_range = value_range
+  end
+
+  sig { override.params(on_sheet: String).returns(String) }
+  def format(on_sheet:)
+    formatted_condition = Zaxcel::Cell.format(@condition, on_sheet: on_sheet)
+    formatted_idx_range = @idx_range.format(on_sheet: on_sheet)
+    formatted_value_range = @value_range.format(on_sheet: on_sheet)
+
+    "XLOOKUP(#{formatted_condition},#{formatted_idx_range},#{formatted_value_range})"
+  end
+end