class SvelteOnRails::Lib::SvelteAttributes

def calculate_instance(record, attributes, associations, call_stack: 0, offset: nil, limit: nil)
  next_stack = call_stack + 1
  if record.respond_to?(:each)
    recs2 = if offset || limit
              if (record.is_a?(ActiveRecord::Relation) || record.is_a?(ActiveRecord::Associations::CollectionProxy) rescue false)
                _recs = (offset ? record.offset(offset) : record)
                (limit ? _recs.limit(limit) : _recs)
              elsif record.respond_to?(:drop) && record.respond_to?(:take) # that might be a array
                _recs = offset ? record.drop(offset) : record
                limit ? _recs.take(limit) : _recs
              else
                raise "[svelte-on-rails:to_svelte] unknown class for records: #{record}"
              end
            else
              record
            end
    # set_labels(record.first, attributes)
    values = recs2.map do |rec|
      calculate_instance(rec, attributes, associations, call_stack: next_stack)
    end
  else
    # we have a single record
    values = {}
    set_labels(record, attributes, associations)
    attributes.each do |attr|
      raise 'Invalid attribute' unless [Symbol, String].include?(attr.class)
      raise "[svelte-on-rails:to_svelte] #{record.class} does not respond to: #{attr}" unless record.respond_to?(attr)
      _key = attr.to_s
      values[_key] = record.send(_key)
    end
    associations.each do |key, val|
      # we have associations
      val.each do |_key|
        next if ['offset', 'limit'].include?(_key.to_s)
        raise "[svelte-on-rails:to_svelte] #{record.class} does not respond to: #{key}" unless record.respond_to?(key)
        _offset, _limit, _value = extract_limit(val)
        _key = key.to_s
        # inspect association and set_labels
        reflect = record.class.reflect_on_association(_key)
        raise "invalid association: #{_key}" unless reflect
        set_labels(reflect, val)
        # values
        recs = record.send(_key)
        if recs.present?
          if recs.respond_to?(:each)
            values[_key] = calculate_instance(
              recs,
              val.reject{|v|v.is_a?(Hash)},
              {},
              call_stack: next_stack,
              offset: _offset,
              limit: _limit
            )
          else
            values[_key] = calculate_instance(
              recs,
              val,
              {},
              call_stack: next_stack
            )
          end
        end
      end
    end
  end
  if call_stack >= 1
    values
  else
    [
      @labels,
      values
    ]
  end
end