admin_suite 0.1.0

data/lib/admin_suite/markdown_renderer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "redcarpet"
+require "rouge"
+require "rouge/plugins/redcarpet"
+
+module AdminSuite
+  # MarkdownRenderer converts markdown text into safe HTML with syntax highlighting.
+  #
+  # Uses Redcarpet for markdown parsing, Rouge for syntax highlighting,
+  # and extracts a table of contents from headings.
+  class MarkdownRenderer
+    attr_reader :markdown
+
+    def initialize(markdown)
+      @markdown = markdown.to_s
+    end
+
+    # @return [Hash{Symbol=>Object}]
+    def render
+      result = self.class.render_with_toc(markdown)
+
+      {
+        html: result[:html],
+        toc: result[:toc],
+        reading_time_minutes: reading_time_minutes
+      }
+    end
+
+    # @param text [String]
+    # @return [ActiveSupport::SafeBuffer]
+    def self.render(text)
+      renderer = HtmlRenderer.new
+      md = Redcarpet::Markdown.new(renderer, markdown_extensions)
+      md.render(text.to_s).html_safe
+    end
+
+    # @param text [String]
+    # @return [Hash{Symbol=>Object}]
+    def self.render_with_toc(text)
+      renderer = HtmlRenderer.new
+      md = Redcarpet::Markdown.new(renderer, markdown_extensions)
+      html = md.render(text.to_s).html_safe
+      { html: html, toc: renderer.toc_items }
+    end
+
+    private
+
+    def self.markdown_extensions
+      {
+        autolink: true,
+        tables: true,
+        fenced_code_blocks: true,
+        strikethrough: true,
+        highlight: true,
+        superscript: true,
+        underline: true,
+        no_intra_emphasis: true,
+        space_after_headers: true,
+        lax_spacing: true
+      }
+    end
+
+    # Rough reading time estimate assuming 200 wpm.
+    # @return [Integer]
+    def reading_time_minutes
+      words = markdown.scan(/\b[\p{L}\p{N}']+\b/).size
+      [ (words / 200.0).ceil, 1 ].max
+    end
+
+    class HtmlRenderer < Redcarpet::Render::HTML
+      include Rouge::Plugins::Redcarpet
+
+      attr_reader :toc_items
+
+      def initialize(extensions = {})
+        super(extensions.merge(
+          hard_wrap: true,
+          link_attributes: { target: "_blank", rel: "noopener noreferrer" },
+          with_toc_data: true
+        ))
+        @toc_items = []
+        @heading_ids = Hash.new(0)
+      end
+
+      def block_code(code, language)
+        language ||= "text"
+        lexer = Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText.new
+        formatter = Rouge::Formatters::HTML.new
+        highlighted = formatter.format(lexer.lex(code))
+
+        lang_label = language != "text" ? %(<span class="code-lang">#{language}</span>) : ""
+        %(<div class="code-block">#{lang_label}<pre class="highlight #{language}"><code>#{highlighted}</code></pre></div>)
+      end
+
+      def header(text, header_level)
+        base_slug = text.to_s.downcase.strip.gsub(/\s+/, "-").gsub(/[^\w-]/, "")
+        base_slug = "section" if base_slug.blank?
+
+        @heading_ids[base_slug] += 1
+        slug = @heading_ids[base_slug] > 1 ? "#{base_slug}-#{@heading_ids[base_slug]}" : base_slug
+
+        if header_level >= 2 && header_level <= 4
+          @toc_items << { level: header_level, id: slug, text: text }
+        end
+
+        %(<h#{header_level} id="#{slug}">#{text}</h#{header_level}>\n)
+      end
+
+      def table(header, body)
+        %(<table class="admin-suite-doc-table"><thead>#{header}</thead><tbody>#{body}</tbody></table>\n)
+      end
+    end
+  end
+end

data/lib/admin_suite/portal_definition.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "admin_suite/ui/dashboard_definition"
+
+module AdminSuite
+  class PortalDefinition
+    attr_reader :key
+
+    def initialize(key)
+      @key = key.to_sym
+      @label = nil
+      @icon = nil
+      @color = nil
+      @order = nil
+      @description = nil
+      @dashboard = nil
+    end
+
+    def label(value = nil)
+      @label = value if value.present?
+      @label
+    end
+
+    def icon(value = nil)
+      @icon = value if value.present?
+      @icon
+    end
+
+    def color(value = nil)
+      @color = value if value.present?
+      @color
+    end
+
+    def order(value = nil)
+      @order = value unless value.nil?
+      @order
+    end
+
+    def description(value = nil)
+      @description = value if value.present?
+      @description
+    end
+
+    def dashboard(&block)
+      @dashboard ||= UI::DashboardDefinition.new
+      UI::DashboardDSL.new(@dashboard).instance_eval(&block) if block_given?
+      @dashboard
+    end
+
+    def dashboard_definition
+      @dashboard
+    end
+
+    def to_nav_meta
+      {
+        label: @label,
+        icon: @icon,
+        color: @color,
+        order: @order,
+        description: @description
+      }.compact
+    end
+  end
+end

data/lib/admin_suite/portal_registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  # Stores portal definitions registered via `AdminSuite.portal`.
+  module PortalRegistry
+    class << self
+      # @return [Hash{Symbol=>AdminSuite::PortalDefinition}]
+      def all
+        @all ||= {}
+      end
+
+      # @param definition [AdminSuite::PortalDefinition]
+      # @return [AdminSuite::PortalDefinition]
+      def register(definition)
+        all[definition.key] = definition
+      end
+
+      # @param key [Symbol, String]
+      # @return [AdminSuite::PortalDefinition, nil]
+      def fetch(key)
+        all[key.to_sym]
+      end
+
+      # Clears the registry (useful for development reloads).
+      #
+      # @return [void]
+      def reset!
+        @all = {}
+      end
+    end
+  end
+end

data/lib/admin_suite/theme_palette.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  module ThemePalette
+    # Minimal Tailwind-like palette values (hex) for theming.
+    # We only include the shades AdminSuite uses.
+    COLORS = {
+      "slate" => { 100 => "#f1f5f9", 200 => "#e2e8f0", 500 => "#64748b", 600 => "#475569", 700 => "#334155", 800 => "#1e293b", 900 => "#0f172a" },
+      "indigo" => { 100 => "#e0e7ff", 200 => "#c7d2fe", 500 => "#6366f1", 600 => "#4f46e5", 700 => "#4338ca", 800 => "#3730a3", 900 => "#312e81" },
+      "purple" => { 100 => "#f3e8ff", 200 => "#e9d5ff", 500 => "#a855f7", 600 => "#9333ea", 700 => "#7e22ce", 800 => "#6b21a8", 900 => "#581c87" },
+      "violet" => { 100 => "#ede9fe", 200 => "#ddd6fe", 500 => "#8b5cf6", 600 => "#7c3aed", 700 => "#6d28d9", 800 => "#5b21b6", 900 => "#4c1d95" },
+      "amber" => { 100 => "#fef3c7", 200 => "#fde68a", 500 => "#f59e0b", 600 => "#d97706", 700 => "#b45309", 800 => "#92400e", 900 => "#78350f" },
+      "emerald" => { 100 => "#d1fae5", 200 => "#a7f3d0", 500 => "#10b981", 600 => "#059669", 700 => "#047857", 800 => "#065f46", 900 => "#064e3b" },
+      "cyan" => { 100 => "#cffafe", 200 => "#a5f3fc", 500 => "#06b6d4", 600 => "#0891b2", 700 => "#0e7490", 800 => "#155e75", 900 => "#164e63" },
+      "blue" => { 100 => "#dbeafe", 200 => "#bfdbfe", 500 => "#3b82f6", 600 => "#2563eb", 700 => "#1d4ed8", 800 => "#1e40af", 900 => "#1e3a8a" },
+      "green" => { 100 => "#dcfce7", 200 => "#bbf7d0", 500 => "#22c55e", 600 => "#16a34a", 700 => "#15803d", 800 => "#166534", 900 => "#14532d" },
+      "red" => { 100 => "#fee2e2", 200 => "#fecaca", 500 => "#ef4444", 600 => "#dc2626", 700 => "#b91c1c", 800 => "#991b1b", 900 => "#7f1d1d" }
+    }.freeze
+
+    def self.resolve(color_name, shade, fallback: nil)
+      return fallback if color_name.blank?
+
+      name = color_name.to_s.delete_prefix(":")
+      COLORS.dig(name, shade) || fallback
+    end
+
+    def self.normalize_color(value, default_name:)
+      return default_name.to_s if value.blank?
+      value.to_s.delete_prefix(":")
+    end
+
+    def self.hex?(value)
+      value.is_a?(String) && value.match?(/\A#(?:[0-9a-fA-F]{3}){1,2}\z/)
+    end
+  end
+end

data/lib/admin_suite/ui/dashboard_definition.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  module UI
+    PanelDefinition = Struct.new(:type, :title, :options, keyword_init: true)
+    RowDefinition = Struct.new(:panels, keyword_init: true)
+
+    class DashboardDefinition
+      attr_reader :rows
+
+      def initialize
+        @rows = []
+      end
+    end
+
+    # DSL used inside `portal.dashboard do ... end`.
+    class DashboardDSL
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def row(&block)
+        row = RowDefinition.new(panels: [])
+        RowDSL.new(row).instance_eval(&block) if block_given?
+        @definition.rows << row
+        row
+      end
+    end
+
+    # DSL used inside `row do ... end`.
+    class RowDSL
+      def initialize(row)
+        @row = row
+      end
+
+      def panel(type, title = nil, span: nil, **options, &block)
+        options[:span] = span if span
+        options[:block] = block if block_given?
+        @row.panels << PanelDefinition.new(type: type.to_sym, title: title, options: options)
+      end
+
+      def stat_panel(title, value = nil, span: nil, **options, &block)
+        value_proc = value.is_a?(Proc) ? value : (block_given? ? block : nil)
+        panel(:stat, title, span: span, **options.merge(value: value_proc || value))
+      end
+
+      def health_panel(title, status: nil, metrics: nil, span: nil, **options, &block)
+        panel(:health, title, span: span, **options.merge(status: status, metrics: metrics, block: block))
+      end
+
+      def chart_panel(title, data: nil, span: nil, **options, &block)
+        data_proc = data.is_a?(Proc) ? data : (block_given? ? block : nil)
+        panel(:chart, title, span: span, **options.merge(data: data_proc || data))
+      end
+
+      def cards_panel(title, resources: nil, span: nil, **options, &block)
+        panel(:cards, title, span: span, **options.merge(resources: resources, block: block))
+      end
+
+      def recent_panel(title, scope: nil, link: nil, span: nil, **options, &block)
+        panel(:recent, title, span: span, **options.merge(scope: scope, link: link, block: block))
+      end
+
+      def table_panel(title, rows: nil, columns: nil, span: nil, **options, &block)
+        panel(:table, title, span: span, **options.merge(rows: rows, columns: columns, block: block))
+      end
+    end
+  end
+end

data/lib/admin_suite/ui/field_renderer_registry.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  module UI
+    module FieldRendererRegistry
+      class << self
+        def handlers
+          @handlers ||= {}
+        end
+
+        def register(type, &block)
+          handlers[type.to_sym] = block
+        end
+
+        def render(type, view:, f:, field:, resource:, field_class:)
+          handler = handlers[type.to_sym]
+          return nil unless handler
+
+          handler.call(view, f, field, resource, field_class)
+        end
+      end
+    end
+  end
+end
+
+# ---- default field renderers ----
+AdminSuite::UI::FieldRendererRegistry.register(:textarea) do |_view, f, field, resource, field_class|
+  f.text_area(field.name, class: field_class, rows: field.rows || 4, placeholder: field.placeholder, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:url) do |_view, f, field, resource, field_class|
+  f.url_field(field.name, class: field_class, placeholder: field.placeholder, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:email) do |_view, f, field, resource, field_class|
+  f.email_field(field.name, class: field_class, placeholder: field.placeholder, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:number) do |_view, f, field, resource, field_class|
+  f.number_field(field.name, class: field_class, placeholder: field.placeholder, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:toggle) do |view, f, field, resource, _field_class|
+  view.render_toggle_field(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:label) do |view, _f, field, resource, _field_class|
+  label_value = resource.public_send(field.name) rescue nil
+  view.render_label_badge(label_value, color: field.label_color, size: field.label_size, record: resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:select) do |_view, f, field, resource, field_class|
+  collection = field.collection.is_a?(Proc) ? field.collection.call : field.collection
+  f.select(field.name, collection, { include_blank: true }, class: field_class, disabled: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:searchable_select) do |view, f, field, resource, _field_class|
+  view.render_searchable_select(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:multi_select) do |view, f, field, resource, _field_class|
+  view.render_multi_select(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:tags) do |view, f, field, resource, _field_class|
+  view.render_multi_select(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:image) do |view, f, field, resource, _field_class|
+  view.render_file_upload(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:attachment) do |view, f, field, resource, _field_class|
+  view.render_file_upload(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:trix) do |_view, f, field, resource, _field_class|
+  f.rich_text_area(field.name, class: "prose dark:prose-invert max-w-none")
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:rich_text) do |_view, f, field, resource, _field_class|
+  f.rich_text_area(field.name, class: "prose dark:prose-invert max-w-none")
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:markdown) do |_view, f, field, resource, field_class|
+  f.text_area(field.name, class: "#{field_class} font-mono", rows: field.rows || 12, data: { controller: "admin-suite--markdown-editor" }, placeholder: field.placeholder)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:file) do |_view, f, field, resource, _field_class|
+  f.file_field(field.name, class: "form-input-file", accept: field.accept)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:datetime) do |_view, f, field, resource, field_class|
+  f.datetime_local_field(field.name, class: field_class, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:date) do |_view, f, field, resource, field_class|
+  f.date_field(field.name, class: field_class, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:time) do |_view, f, field, resource, field_class|
+  f.time_field(field.name, class: field_class, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:json) do |view, f, field, resource, _field_class|
+  view.render("admin_suite/shared/json_editor_field", f: f, field: field, resource: resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:code) do |view, f, field, resource, _field_class|
+  view.render_code_editor(f, field, resource)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:text) do |_view, f, field, resource, field_class|
+  f.text_field(field.name, class: field_class, placeholder: field.placeholder, readonly: field.readonly)
+end
+
+AdminSuite::UI::FieldRendererRegistry.register(:string) do |_view, f, field, resource, field_class|
+  f.text_field(field.name, class: field_class, placeholder: field.placeholder, readonly: field.readonly)
+end

data/lib/admin_suite/ui/form_field_renderer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "admin_suite/ui/field_renderer_registry"
+
+module AdminSuite
+  module UI
+    # Overrides `render_form_field` to use a registry of field renderers,
+    # while leaving the legacy implementation available via `super`.
+    module FormFieldRenderer
+      def render_form_field(f, field, resource)
+        return super unless defined?(AdminSuite::UI::FieldRendererRegistry)
+
+        return if field.if_condition.present? && !field.if_condition.call(resource)
+        return if field.unless_condition.present? && field.unless_condition.call(resource)
+
+        capture do
+          concat(content_tag(:div, class: "form-group") do
+            concat(f.label(field.name, class: "form-label") do
+              concat(field.label)
+              concat(content_tag(:span, " *", class: "text-red-500")) if field.required
+            end)
+
+            field_class = "form-input w-full"
+            field_class += " border-red-500" if resource.errors[field.name].any?
+
+            field_html =
+              AdminSuite::UI::FieldRendererRegistry.render(
+                field.type || :text,
+                view: self,
+                f: f,
+                field: field,
+                resource: resource,
+                field_class: field_class
+              )
+
+            # If the registry doesn't know how to render, fall back to legacy behavior.
+            return super if field_html.nil?
+
+            concat(field_html)
+
+            concat(content_tag(:p, field.help, class: "mt-1 text-sm text-slate-500 dark:text-slate-400")) if field.help.present?
+            concat(content_tag(:p, resource.errors[field.name].first, class: "mt-1 text-sm text-red-600 dark:text-red-400")) if resource.errors[field.name].any?
+          end)
+        end
+      end
+    end
+  end
+end

data/lib/admin_suite/ui/show_formatter_registry.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  module UI
+    module ShowFormatterRegistry
+      class << self
+        def class_handlers
+          @class_handlers ||= {}
+        end
+
+        def default_handler
+          @default_handler
+        end
+
+        def register_class(klass, &block)
+          class_handlers[klass] = block
+        end
+
+        def register_default(&block)
+          @default_handler = block
+        end
+
+        def format(value, view:, record:, field_name:)
+          handler = class_handlers.find { |klass, _| value.is_a?(klass) }&.last
+          handler ||= default_handler
+          return nil unless handler
+
+          handler.call(value, view, record, field_name)
+        end
+      end
+    end
+  end
+end
+
+# ---- default show formatters ----
+AdminSuite::UI::ShowFormatterRegistry.register_class(NilClass) do |_value, view, _record, _field|
+  view.content_tag(:span, "—", class: "text-slate-400")
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(TrueClass) do |_value, view, _record, _field|
+  view.content_tag(:span, class: "inline-flex items-center gap-1") do
+    view.concat(view.admin_suite_icon("check-circle-2", class: "w-4 h-4 text-green-500"))
+    view.concat(view.content_tag(:span, "Yes", class: "text-green-600 dark:text-green-400 font-medium"))
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(FalseClass) do |_value, view, _record, _field|
+  view.content_tag(:span, class: "inline-flex items-center gap-1") do
+    view.concat(view.admin_suite_icon("x-circle", class: "w-4 h-4 text-slate-400"))
+    view.concat(view.content_tag(:span, "No", class: "text-slate-500"))
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Time) do |value, view, _record, _field|
+  view.content_tag(:span, class: "inline-flex items-center gap-2") do
+    view.concat(view.content_tag(:span, value.strftime("%B %d, %Y at %H:%M"), class: "font-medium"))
+    view.concat(view.content_tag(:span, "(#{view.time_ago_in_words(value)} ago)", class: "text-slate-500 dark:text-slate-400 text-xs"))
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(DateTime) do |value, view, _record, _field|
+  view.content_tag(:span, class: "inline-flex items-center gap-2") do
+    view.concat(view.content_tag(:span, value.strftime("%B %d, %Y at %H:%M"), class: "font-medium"))
+    view.concat(view.content_tag(:span, "(#{view.time_ago_in_words(value)} ago)", class: "text-slate-500 dark:text-slate-400 text-xs"))
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Date) do |value, _view, _record, _field|
+  value.strftime("%B %d, %Y")
+end
+
+if defined?(ActiveRecord::Base)
+  AdminSuite::UI::ShowFormatterRegistry.register_class(ActiveRecord::Base) do |value, view, _record, _field|
+    link_text = value.respond_to?(:name) ? value.name : "#{value.class.name} ##{value.id}"
+    view.content_tag(:span, link_text, class: "text-indigo-600 dark:text-indigo-400")
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Hash) do |value, view, _record, _field|
+  view.render_json_block(value)
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Array) do |value, view, _record, _field|
+  if value.empty?
+    view.content_tag(:span, "Empty array", class: "text-slate-400 italic")
+  elsif value.first.is_a?(Hash)
+    view.render_json_block(value)
+  else
+    view.content_tag(:div, class: "flex flex-wrap gap-1") do
+      value.each do |item|
+        view.concat(view.content_tag(:span, item.to_s, class: "inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-slate-100 dark:bg-slate-700 text-slate-700 dark:text-slate-300"))
+      end
+    end
+  end
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Integer) do |value, view, _record, _field|
+  view.content_tag(:span, view.number_with_delimiter(value), class: "font-mono")
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_class(Float) do |value, view, _record, _field|
+  view.content_tag(:span, view.number_with_delimiter(value), class: "font-mono")
+end
+
+AdminSuite::UI::ShowFormatterRegistry.register_default do |value, view, _record, field_name|
+  value_str = value.to_s
+
+  if value_str.start_with?("{", "[") && value_str.length > 10
+    begin
+      parsed = JSON.parse(value_str)
+      view.render_json_block(parsed)
+    rescue JSON::ParserError
+      view.render_text_block(value_str)
+    end
+  elsif value_str.include?("\n") || value_str.length > 200
+    view.render_text_block(value_str, view.detect_language(field_name, value_str))
+  else
+    value_str
+  end
+end

data/lib/admin_suite/ui/show_value_formatter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "admin_suite/ui/show_formatter_registry"
+
+module AdminSuite
+  module UI
+    # Overrides `format_show_value` to use a registry of show value formatters,
+    # while leaving the legacy implementation available via `super`.
+    module ShowValueFormatter
+      def format_show_value(record, field_name)
+        value = record.public_send(field_name) rescue nil
+
+        if (field_def = admin_suite_field_definition(field_name))
+          case field_def.type
+          when :markdown
+            rendered =
+              if defined?(::MarkdownRenderer)
+                ::MarkdownRenderer.render(value.to_s)
+              else
+                simple_format(value.to_s)
+              end
+            return content_tag(:div, rendered, class: "prose dark:prose-invert max-w-none")
+          when :json
+            begin
+              parsed =
+                if value.is_a?(Hash) || value.is_a?(Array)
+                  value
+                elsif value.present?
+                  JSON.parse(value.to_s)
+                end
+              return render_json_block(parsed) if parsed
+            rescue JSON::ParserError
+              # fall through
+            end
+          when :label
+            return render_label_badge(value, color: field_def.label_color, size: field_def.label_size, record: record)
+          end
+        end
+
+        # If the field isn't in the form config, fall back to index column config
+        # so show pages can still render labels consistently.
+        if respond_to?(:resource_config, true) && (rc = resource_config) && rc.index_config&.columns_list
+          col = rc.index_config.columns_list.find { |c| c.name.to_sym == field_name.to_sym }
+          if col&.type == :label
+            label_value = col.content.is_a?(Proc) ? col.content.call(record) : value
+            return render_label_badge(label_value, color: col.label_color, size: col.label_size, record: record)
+          end
+        end
+
+        if value.is_a?(ActiveStorage::Attached::One)
+          return render_attachment_preview(value)
+        elsif value.is_a?(ActiveStorage::Attached::Many)
+          return render_attachments_preview(value)
+        end
+
+        formatted =
+          AdminSuite::UI::ShowFormatterRegistry.format(
+            value,
+            view: self,
+            record: record,
+            field_name: field_name
+          )
+
+        return formatted unless formatted.nil?
+
+        super
+      end
+    end
+  end
+end

data/lib/admin_suite/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  module Version
+    VERSION = "0.1.0"
+  end
+
+  # Backward-compatible constant.
+  VERSION = Version::VERSION
+end