rails_admin_next 1.0.0

data/app/helpers/rails_admin_next/application_helper.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module ApplicationHelper
+    def authorized?(action_name, abstract_model = nil, object = nil)
+      object = nil if object.try :new_record?
+      action(action_name, abstract_model, object).try(:authorized?)
+    end
+
+    def current_action
+      params[:action].in?(%w[create new]) ? "create" : "update"
+    end
+
+    def current_action?(action, abstract_model = @abstract_model, object = @object)
+      @action.custom_key == action.custom_key &&
+        abstract_model.try(:to_param) == @abstract_model.try(:to_param) &&
+        (@object.try(:persisted?) ? @object.id == object.try(:id) : !object.try(:persisted?))
+    end
+
+    def action(key, abstract_model = nil, object = nil)
+      RailsAdminNext::Config::Actions.find(key, controller: controller, abstract_model: abstract_model, object: object)
+    end
+
+    # Render an engine icon as inline SVG. `name` is a logical icon name (see
+    # RailsAdminNext::Icons::GLYPHS), e.g. :edit, :delete, :list. A nil/unknown
+    # name renders nothing rather than raising; a legacy Font Awesome class string
+    # is resolved best-effort and warns via RailsAdminNext.deprecator.
+    def rails_admin_icon(name, **html_options)
+      RailsAdminNext::Icons.svg(name, **html_options)&.html_safe || "".html_safe
+    end
+
+    def actions(scope = :all, abstract_model = nil, object = nil)
+      RailsAdminNext::Config::Actions.all(scope, controller: controller, abstract_model: abstract_model, object: object)
+    end
+
+    def edit_user_link
+      return nil unless _current_user.try(:email).present?
+      return nil unless (abstract_model = RailsAdminNext.config(_current_user.class).abstract_model)
+
+      edit_action = action(:edit, abstract_model, _current_user)
+      authorized = edit_action.try(:authorized?)
+      content = edit_user_link_label
+
+      if authorized
+        edit_url = rails_admin_next.url_for(
+          action: edit_action.action_name,
+          model_name: abstract_model.to_param,
+          controller: "rails_admin_next/main",
+          id: _current_user.id
+        )
+
+        link_to content, edit_url, class: "nav-link"
+      else
+        content_tag :span, content, class: "nav-link"
+      end
+    end
+
+    def logout_path
+      main_app.logout_path if main_app.respond_to?(:logout_path)
+    end
+
+    def logout_method
+      :delete
+    end
+
+    def wording_for(label, action = @action, abstract_model = @abstract_model, object = @object)
+      model_config = abstract_model.try(:config)
+      object = nil unless abstract_model && object.is_a?(abstract_model.model)
+      action = RailsAdminNext::Config::Actions.find(action.to_sym) if action.is_a?(Symbol) || action.is_a?(String)
+
+      I18n.t(
+        "admin.actions.#{action.i18n_key}.#{label}",
+        model_label: model_config&.label,
+        model_label_plural: model_config&.label_plural,
+        object_label: model_config && object.try(model_config.object_label_method)
+      )
+    end
+
+    def main_navigation
+      nodes_stack = RailsAdminNext::Config.visible_models(controller: controller)
+      node_model_names = nodes_stack.collect { |c| c.abstract_model.model_name }
+      parent_groups = nodes_stack.group_by { |n| n.parent&.to_s }
+
+      nodes_stack.group_by(&:navigation_label).collect do |navigation_label, nodes|
+        nodes = nodes.select { |n| n.parent.nil? || !n.parent.to_s.in?(node_model_names) }
+        li_stack = navigation parent_groups, nodes
+
+        label = navigation_label || t("admin.misc.navigation")
+
+        collapsible_stack(label, "main", li_stack)
+      end.join.html_safe
+    end
+
+    def root_navigation
+      actions(:root).select(&:show_in_sidebar).group_by(&:sidebar_label).collect do |label, nodes|
+        li_stack = nodes.map do |node|
+          url = rails_admin_next.url_for(action: node.action_name, controller: "rails_admin_next/main")
+          nav_icon = rails_admin_icon(node.link_icon)
+          content_tag :li do
+            link_to nav_icon + " " + wording_for(:menu, node), url, class: "nav-link"
+          end
+        end.join.html_safe
+        label ||= t("admin.misc.root_navigation")
+
+        collapsible_stack(label, "action", li_stack)
+      end.join.html_safe
+    end
+
+    def static_navigation
+      li_stack = RailsAdminNext::Config.navigation_static_links.collect do |title, url|
+        content_tag(:li, link_to(title.to_s, url, target: "_blank", rel: "noopener noreferrer", class: "nav-link"))
+      end.join.html_safe
+
+      label = RailsAdminNext::Config.navigation_static_label || t("admin.misc.navigation_static_label")
+      collapsible_stack(label, "static", li_stack) || ""
+    end
+
+    def navigation(parent_groups, nodes, level = 0)
+      nodes.collect do |node|
+        abstract_model = node.abstract_model
+        model_param = abstract_model.to_param
+        url = rails_admin_next.url_for(action: :index, controller: "rails_admin_next/main", model_name: model_param)
+        nav_icon = rails_admin_icon(node.navigation_icon)
+        css_classes = ["nav-link"]
+        css_classes.push("nav-level-#{level}") if level > 0
+        css_classes.push("active") if @action && current_action?(@action, model_param)
+        li = content_tag :li, data: {model: model_param} do
+          link_to nav_icon + " " + node.label_plural, url, class: css_classes.join(" ")
+        end
+        child_nodes = parent_groups[abstract_model.model_name]
+        child_nodes ? li + navigation(parent_groups, child_nodes, level + 1) : li
+      end.join.html_safe
+    end
+
+    def breadcrumb(action = @action, _acc = [])
+      begin
+        (parent_actions ||= []) << action
+      end while action.breadcrumb_parent && (action = action(*action.breadcrumb_parent)) # rubocop:disable Lint/Loop
+
+      content_tag(:ol, class: "breadcrumb") do
+        parent_actions.collect do |a|
+          am = a.send(:eval, "bindings[:abstract_model]")
+          o = a.send(:eval, "bindings[:object]")
+          content_tag(:li, class: ["breadcrumb-item", current_action?(a, am, o) && "active"]) do
+            if current_action?(a, am, o)
+              wording_for(:breadcrumb, a, am, o)
+            elsif a.http_methods.include?(:get)
+              link_to rails_admin_next.url_for(action: a.action_name, controller: "rails_admin_next/main", model_name: am.try(:to_param), id: o.try(:persisted?) && o.try(:id) || nil) do
+                wording_for(:breadcrumb, a, am, o)
+              end
+            else
+              content_tag(:span, wording_for(:breadcrumb, a, am, o))
+            end
+          end
+        end.reverse.join.html_safe
+      end
+    end
+
+    # parent => :root, :collection, :member
+    # perf matters here (no action view trickery)
+    def menu_for(parent, abstract_model = nil, object = nil, only_icon = false)
+      actions = actions(parent, abstract_model, object).select { |a| a.http_methods.include?(:get) && a.show_in_menu }
+      actions.collect do |action|
+        wording = wording_for(:menu, action)
+        li_class = ["nav-item", "icon", "#{action.key}_#{parent}_link"]
+          .concat(action.enabled? ? [] : ["disabled"])
+        content_tag(:li, {class: li_class}.merge(only_icon ? {title: wording, rel: "tooltip"} : {})) do
+          label = rails_admin_icon(action.link_icon) + " " + content_tag(:span, wording, (only_icon ? {style: "display:none"} : {}))
+          if action.enabled? || !only_icon
+            href =
+              if action.enabled?
+                rails_admin_next.url_for(action: action.action_name, controller: "rails_admin_next/main", model_name: abstract_model.try(:to_param), id: object.try(:persisted?) && object.try(:id) || nil)
+              else
+                "javascript:void(0)"
+              end
+            content_tag(:a, label, {href: href, target: action.link_target, class: ["nav-link", current_action?(action) && "active", !action.enabled? && "disabled"].compact}.merge(action.turbo? ? {} : {data: {turbo: "false"}}))
+          else
+            content_tag(:span, label)
+          end
+        end
+      end.join(" ").html_safe
+    end
+
+    def bulk_menu(abstract_model = @abstract_model)
+      actions = actions(:bulkable, abstract_model)
+      return "" if actions.empty?
+
+      content_tag :li, class: "nav-item dropdown" do
+        content_tag(:button, type: "button", id: "bulk_menu_toggle", class: "nav-link dropdown-toggle", popovertarget: "bulk_menu", data: {controller: "dropdown", action: "keydown->dropdown#onKeydown"}) { t("admin.misc.bulk_menu_title").html_safe + " " + '<b class="caret"></b>'.html_safe } +
+          content_tag(:ul, id: "bulk_menu", class: "dropdown-menu dropdown-menu-end", role: "menu", popover: "auto") do
+            actions.collect do |action|
+              content_tag :li, role: "none" do
+                link_to wording_for(:bulk_link, action, abstract_model), "#", class: "dropdown-item bulk-link", role: "menuitem", tabindex: "-1", data: {action: action.action_name}
+              end
+            end.join.html_safe
+          end
+      end.html_safe
+    end
+
+    def flash_alert_class(flash_key)
+      case flash_key.to_s
+      when "error" then "alert-danger"
+      when "alert" then "alert-warning"
+      when "notice" then "alert-info"
+      else "alert-#{flash_key}"
+      end
+    end
+
+    # Workaround for https://github.com/rails/rails/issues/31325
+    def image_tag(source, options = {})
+      if %w[ActiveStorage::Variant ActiveStorage::VariantWithRecord ActiveStorage::Preview].include? source.class.to_s
+        super(main_app.route_for(ActiveStorage.resolve_model_to_route, source), options)
+      else
+        super
+      end
+    end
+
+    private
+
+    def edit_user_link_label
+      [
+        RailsAdminNext::Config.show_gravatar &&
+          image_tag(gravatar_url(_current_user.email), alt: ""),
+
+        content_tag(:span, _current_user.email)
+      ].filter(&:present?).join.html_safe
+    end
+
+    def gravatar_url(email)
+      "https://secure.gravatar.com/avatar/#{Digest::MD5.hexdigest email}?s=30"
+    end
+
+    # Native disclosure: the group renders open and the browser owns toggling.
+    # The MD5-derived key is stable across renders, so a `turbo:before-render`
+    # hook (src/rails_admin/interactions.js) can carry a collapsed group's state
+    # into the next page. Find-in-page may auto-expand a collapsed group; that's
+    # accepted <details> platform behavior.
+    def collapsible_stack(label, class_prefix, li_stack)
+      return nil unless li_stack.present?
+
+      collapse_key = "#{class_prefix}-#{Digest::MD5.hexdigest(label)[0..7]}"
+      content_tag(:li, class: "mb-1") do
+        content_tag(:details, open: true, data: {collapse_key: collapse_key}) do
+          content_tag(:summary, class: "btn btn-toggle align-items-center rounded") do
+            rails_admin_icon(:collapse) + html_escape(" " + label)
+          end +
+            content_tag(:ul, class: "btn-toggle-nav list-unstyled fw-normal pb-1") do
+              li_stack
+            end
+        end
+      end
+    end
+  end
+end

data/app/helpers/rails_admin_next/form_builder.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  class FormBuilder < ::ActionView::Helpers::FormBuilder
+    include ::RailsAdminNext::ApplicationHelper
+
+    def generate(options = {})
+      without_field_error_proc_added_div do
+        options.reverse_merge!(
+          action: @template.controller.params[:action],
+          model_config: @template.instance_variable_get(:@model_config),
+          nested_in: false
+        )
+
+        object_infos +
+          visible_groups(options[:model_config], generator_action(options[:action], options[:nested_in])).collect do |fieldset|
+            fieldset_for fieldset, options[:nested_in]
+          end.join.html_safe +
+          (options[:nested_in] ? "" : @template.render(partial: "rails_admin_next/main/submit_buttons"))
+      end
+    end
+
+    def fieldset_for(fieldset, nested_in)
+      fields = fieldset.with(
+        form: self,
+        object: @object,
+        view: @template,
+        controller: @template.controller
+      ).visible_fields
+      return if fields.empty?
+
+      @template.content_tag :fieldset do
+        contents = []
+        chevron = RailsAdminNext::Icons.svg(:collapse, class: ("collapsed" unless fieldset.active?)).html_safe
+        legend = @template.safe_join([chevron, " #{fieldset.label}"])
+        contents << @template.content_tag(:legend, legend, style: (fieldset.name == :default) ? "display:none" : "")
+        contents << @template.content_tag(:p, fieldset.help) if fieldset.help.present?
+        contents << fields.collect { |field| field_wrapper_for(field, nested_in) }.join
+        contents.join.html_safe
+      end
+    end
+
+    def field_wrapper_for(field, nested_in)
+      # do not show nested field if the target is the origin
+      return if nested_field_association?(field, nested_in)
+
+      @template.content_tag(:div, class: "control-group row mb-3 #{field.type_css_class} #{field.css_class} #{"error" if field.errors.present?}", id: "#{dom_id(field)}_field") do
+        if field.label
+          label(field.method_name, field.label, class: "col-sm-2 col-form-label text-md-end") +
+            (field.nested_form ? field_for(field) : input_for(field))
+        else
+          field.nested_form ? field_for(field) : input_for(field)
+        end
+      end
+    end
+
+    def input_for(field)
+      css = "col-sm-10 controls"
+      css += " has-error" if field.errors.present?
+      @template.content_tag(:div, class: css) do
+        field_for(field) +
+          errors_for(field) +
+          help_for(field)
+      end
+    end
+
+    def errors_for(field)
+      field.errors.present? ? @template.content_tag(:span, field.errors.to_sentence, class: "help-inline text-danger") : "".html_safe
+    end
+
+    def help_for(field)
+      field.help.present? ? @template.content_tag(:div, field.help, class: "form-text") : "".html_safe
+    end
+
+    def field_for(field)
+      field.read_only? ? @template.content_tag(:div, field.pretty_value, class: "form-control-static") : field.render
+    end
+
+    # Wraps one nested-attributes subform (rendered by native `fields_for`) for
+    # the nested-form Stimulus controller: a `.fields` container, an optional
+    # `_destroy` hidden field + remove button (gated on `allow_destroy`, always
+    # present in the blank <template>), then the recursively generated fields.
+    def nested_field_set(nested_form, field, allow_destroy:)
+      @template.content_tag(:div, class: "fields tab-pane active", data: {"nested-form-target": "subform"}) do
+        contents = []
+        # Keep the persisted-record id inside the `.fields` wrapper (Rails would
+        # otherwise append it as a sibling); the controller reads it to tell a
+        # persisted subform from a brand-new one. Suppress the auto-id in the
+        # partials with `include_id: false` so it is not rendered twice.
+        contents << nested_form.hidden_field(:id) if nested_form.object.persisted?
+        if allow_destroy
+          contents << nested_form.hidden_field(:_destroy, data: {"nested-form-target": "destroy"})
+          contents << @template.content_tag(:button, RailsAdminNext::Icons.svg(:trash).html_safe, type: "button", class: "btn btn-danger remove_nested_fields", data: {action: "nested-form#remove"})
+        end
+        contents << nested_form.generate(action: :nested, model_config: field.associated_model_config, nested_in: field)
+        contents.join.html_safe
+      end
+    end
+
+    def object_infos
+      model_config = RailsAdminNext.config(object)
+      model_label = model_config.label
+      object_label =
+        if object.new_record?
+          I18n.t("admin.form.new_model", name: model_label)
+        else
+          object.send(model_config.object_label_method).presence || "#{model_config.label} ##{object.id}"
+        end
+
+      %(<span hidden class="object-infos" data-model-label="#{CGI.escapeHTML(model_label.to_s)}" data-object-label="#{CGI.escapeHTML(object_label.to_s)}"></span>).html_safe
+    end
+
+    def dom_id(field)
+      (@dom_id ||= {})[field.name] ||=
+        [
+          @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, ""),
+          options[:index],
+          field.method_name
+        ].reject(&:blank?).join("_")
+    end
+
+    def dom_name(field)
+      (@dom_name ||= {})[field.name] ||= %(#{@object_name}#{options[:index] && "[#{options[:index]}]"}[#{field.method_name}]#{"[]" if field.is_a?(Config::Fields::Association) && field.multiple?})
+    end
+
+    def hidden_field(method, options = {})
+      if method == :id && object.id.is_a?(Array)
+        super(method, {value: RailsAdminNext.config.composite_keys_serializer.serialize(object.id)})
+      else
+        super
+      end
+    end
+
+    protected
+
+    def generator_action(action, nested)
+      if nested
+        action = :nested
+      elsif @template.request.format == "text/javascript"
+        action = :modal
+      end
+
+      action
+    end
+
+    def visible_groups(model_config, action)
+      model_config.send(action).with(
+        form: self,
+        object: @object,
+        view: @template,
+        controller: @template.controller
+      ).visible_groups
+    end
+
+    def without_field_error_proc_added_div
+      default_field_error_proc = ::ActionView::Base.field_error_proc
+      begin
+        ::ActionView::Base.field_error_proc = proc { |html_tag, _instance| html_tag }
+        yield
+      ensure
+        ::ActionView::Base.field_error_proc = default_field_error_proc
+      end
+    end
+
+    private
+
+    def nested_field_association?(field, nested_in)
+      field.inverse_of.presence && nested_in.presence && field.inverse_of == nested_in.name &&
+        (@template.instance_variable_get(:@model_config).abstract_model == field.abstract_model ||
+         field.name == nested_in.inverse_of)
+    end
+  end
+end

data/app/helpers/rails_admin_next/main_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module MainHelper
+    def rails_admin_form_for(*args, &)
+      options = args.extract_options!.reverse_merge(builder: RailsAdminNext::FormBuilder)
+      (options[:html] ||= {})[:novalidate] ||= !RailsAdminNext::Config.browser_validations
+      html_data = (options[:html][:data] ||= {})
+      html_data[:controller] = [html_data[:controller], "feedback"].compact.join(" ")
+      html_data[:action] = [html_data[:action], "turbo:submit-start->feedback#start turbo:submit-end->feedback#end"].compact.join(" ")
+
+      form_for(*(args << options), &)
+    end
+
+    def get_indicator(percent)
+      return "" if percent < 0          # none
+      return "info" if percent < 34     # < 1/100 of max
+      return "success" if percent < 67  # < 1/10 of max
+      return "warning" if percent < 84  # < 1/3 of max
+
+      "danger"                          # > 1/3 of max
+    end
+
+    def filterable_fields
+      @filterable_fields ||= @model_config.list.fields.select(&:filterable?)
+    end
+
+    def ordered_filters
+      return @ordered_filters if @ordered_filters.present?
+
+      @index = 0
+      @ordered_filters = (params[:f].try(:permit!).try(:to_h) || @model_config.list.filters).each_with_object({}) do |filter, memo|
+        field_name = filter.is_a?(Array) ? filter.first : filter
+        (filter.is_a?(Array) ? filter.last : {(@index += 1) => {"v" => ""}}).each do |index, filter_hash|
+          if filter_hash["disabled"].blank?
+            memo[index] = {field_name => filter_hash}
+          else
+            params[:f].delete(field_name)
+          end
+        end
+      end.to_a.sort_by(&:first)
+    end
+
+    def ordered_filter_options
+      if ordered_filters
+        @ordered_filter_options ||= ordered_filters.map do |duplet|
+          filter_for_field = duplet[1]
+          filter_name = filter_for_field.keys.first
+          filter_hash = filter_for_field.values.first
+          unless (field = filterable_fields.find { |f| f.name == filter_name.to_sym }&.with({view: self}))
+            raise "#{filter_name} is not currently filterable; filterable fields are #{filterable_fields.map(&:name).join(", ")}"
+          end
+
+          field.filter_options.merge(
+            index: duplet[0],
+            operator: filter_hash["o"] || field.default_filter_operator,
+            value: filter_hash["v"]
+          )
+        end
+      end
+    end
+  end
+end

data/app/views/layouts/rails_admin_next/_head.html.erb

@@ -0,0 +1,29 @@
+<%# locals: () -%>
+<meta content="IE=edge" http-equiv="X-UA-Compatible">
+<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
+<meta content="width=device-width, initial-scale=1" name="viewport; charset=utf-8">
+<meta content="NONE,NOARCHIVE" name="robots">
+<meta content="false" name="turbo-prefetch">
+<%= csrf_meta_tag %>
+<%# The scheme every light-dark() token pair in the engine CSS resolves against. Placed before the
+    stylesheet link so the scheme is known before first paint; a meta (not an inline style) keeps
+    CSP out of the picture and lets :light/:dark pins override the OS preference. %>
+<meta content="<%= {auto: 'light dark', light: 'light', dark: 'dark'}.fetch(RailsAdminNext.config.color_scheme) %>" name="color-scheme">
+<%# The entry stylesheet pulls tokens/framework/skin via @import, which the browser only discovers
+    after fetching and parsing the entry file. Preload the three targets so all four fetch in parallel. %>
+<link rel="preload" as="style" href="<%= asset_path('rails_admin/tokens.css') %>">
+<link rel="preload" as="style" href="<%= asset_path('rails_admin/framework.css') %>">
+<link rel="preload" as="style" href="<%= asset_path('rails_admin/skin.css') %>">
+<%# Date/time fields use native HTML5 inputs; the picker UI is the browser's. Icons are inline SVG (no icon font). %>
+<%= stylesheet_link_tag "rails_admin", media: :all, data: {'turbo-track': 'reload'} %>
+<%# Rich-text (ActionText) fields render a Trix editor; load its stylesheet so the toolbar is styled.
+    trix.css ships with the action_text-trix gem and is on the Propshaft load path when ActionText is used.
+    NOTE: trix.css is light-only for now — dark styling for the Trix toolbar/editor is deferred. %>
+<% if defined?(ActionText::Engine) %>
+  <%= stylesheet_link_tag "trix", media: :all, data: {'turbo-track': 'reload'} %>
+<% end %>
+<%# Zero-build delivery: browser-native ESM pinned by the engine-owned importmap, served by Propshaft.
+    The importmap-rails helpers thread the request CSP nonce onto every inline <script> they emit. %>
+<%= javascript_inline_importmap_tag(RailsAdminNext::Engine.importmap.to_json(resolver: self)) %>
+<%= javascript_importmap_module_preload_tags(RailsAdminNext::Engine.importmap) %>
+<%= javascript_import_module_tag 'rails_admin' %>

data/app/views/layouts/rails_admin_next/_navigation.html.erb

@@ -0,0 +1,18 @@
+<%# locals: () -%>
+<div class="container-fluid" data-controller="collapse">
+  <a class="navbar-brand" href="<%= dashboard_path %>">
+    Rails
+    <small>
+      AdminNext
+    </small>
+  </a>
+  <button class="navbar-toggler" type="button" data-collapse-target="trigger" data-action="collapse#toggle" aria-expanded="false" aria-controls="secondary-navigation">
+    <span class="sr-only">
+      <%= t('admin.toggle_navigation') %>
+    </span>
+    <span class="navbar-toggler-icon"></span>
+  </button>
+  <div class="collapse navbar-collapse" id="secondary-navigation" data-collapse-target="region">
+    <%= render partial: 'layouts/rails_admin_next/secondary_navigation' %>
+  </div>
+</div>

data/app/views/layouts/rails_admin_next/_secondary_navigation.html.erb

@@ -0,0 +1,27 @@
+<%# locals: () -%>
+<ul class="navbar-nav ms-auto root_links">
+  <% actions(:root).select(&:show_in_navigation).each do |action| %>
+    <li class="nav-item <%= action.action_name %>_root_link">
+      <%= link_to wording_for(:menu, action), { action: action.action_name, controller: 'rails_admin_next/main' }, {class: ['nav-link']}.merge(action.turbo? ? {} : {data: {turbo: 'false'}}) %>
+    </li>
+  <% end %>
+  <% if main_app_root_path = (main_app.root_path rescue false) %>
+    <li class="nav-item">
+      <%= link_to t('admin.home.name'), main_app_root_path, class: 'nav-link' %>
+    </li>
+  <% end %>
+  <% if _current_user %>
+    <% if user_link = edit_user_link %>
+      <li class="nav-item edit_user_root_link">
+        <%= user_link %>
+      </li>
+    <% end %>
+    <% if logout_path.present? %>
+      <li class="nav-item">
+        <%= link_to logout_path, class: 'nav-link', data: {turbo_method: logout_method} do %>
+          <span class="badge bg-danger"><%= t('admin.misc.log_out') %></span>
+        <% end %>
+      </li>
+    <% end %>
+  <% end %>
+</ul>

data/app/views/layouts/rails_admin_next/_sidebar_navigation.html.erb

@@ -0,0 +1,6 @@
+<%# locals: () -%>
+<ul class="sidebar col-sm-3 col-md-2 nav btn-toggle-nav flex-column flex-nowrap bg-light">
+  <%= main_navigation %>
+  <%= root_navigation %>
+  <%= static_navigation %>
+</ul>

data/app/views/layouts/rails_admin_next/application.html.erb

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="<%= I18n.locale %>">
+  <head>
+    <%= render "layouts/rails_admin_next/head" %>
+  </head>
+  <body class="rails_admin">
+    <div data-i18n-options="<%= I18n.t("admin.js").to_json %>" id="admin-js"></div>
+    <div class="badge bg-warning" id="loading" style="display:none; position:fixed; right:20px; bottom:20px; z-index:100000">
+      <%= t('admin.loading') %>
+    </div>
+    <nav class="navbar navbar-expand-md fixed-top <%= RailsAdminNext::Config.navbar_css_classes.join(' ') %>">
+      <%= render "layouts/rails_admin_next/navigation" %>
+    </nav>
+    <div class="container-fluid">
+      <div class="row">
+        <div class="col-sm-3 col-md-2 flex-wrap p-0">
+          <%= render "layouts/rails_admin_next/sidebar_navigation" %>
+        </div>
+        <div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2">
+          <div class="container-fluid">
+            <%= render template: 'layouts/rails_admin_next/content' %>
+          </div>
+        </div>
+      </div>
+    </div>
+    <%# Native dialog: the platform owns the top layer, focus trap, Escape and
+        (via closedby="any") backdrop light-dismissal. The title is seeded with
+        the loading string and the body flagged busy so a just-opened dialog
+        has an accessible name and state before the async form arrives. %>
+    <dialog id="modal" closedby="any" aria-labelledby="modal-title" data-controller="modal">
+      <div class="modal-header">
+        <h3 class="modal-header-title" id="modal-title" data-modal-target="title"><%= t('admin.loading') %></h3>
+        <button type="button" class="btn-close" data-action="modal#close" aria-label="<%= t('admin.form.cancel') %>"></button>
+      </div>
+      <div class="modal-body" aria-busy="true" data-modal-target="body"></div>
+      <div class="modal-footer">
+        <a href="#" class="btn cancel-action" data-modal-target="cancelButton" data-action="modal#close"></a>
+        <a href="#" class="btn btn-primary save-action" data-modal-target="saveButton" data-action="modal#save"></a>
+      </div>
+    </dialog>
+  </body>
+</html>

data/app/views/layouts/rails_admin_next/content.html.erb

@@ -0,0 +1,22 @@
+<title>
+  <%= "#{@abstract_model.try(:pretty_name) || @page_name} | Rails AdminNext" %>
+</title>
+<header class="py-2 m-2 border-bottom" data-model="<%= @abstract_model.to_param %>">
+  <h1>
+    <%= @page_name %>
+  </h1>
+</header>
+<% flash && flash.each do |key, value| %>
+  <div class="<%= flash_alert_class(key) %> alert alert-dismissible" data-controller="alert">
+    <%= value %>
+    <button type="button" class="btn-close" data-action="alert#dismiss" aria-label="Close"></button>
+  </div>
+<% end %>
+<nav aria-label="breadcrumb">
+  <%= breadcrumb %>
+</nav>
+<ul class="nav nav-tabs mb-3">
+  <%= menu_for((@abstract_model ? (@object.try(:persisted?) ? :member : :collection) : :root), @abstract_model, @object) %>
+  <%= content_for :contextual_tabs %>
+</ul>
+<%= yield %>

data/app/views/layouts/rails_admin_next/modal.js.erb

@@ -0,0 +1,7 @@
+<% flash && flash.each do |key, value| %>
+  <div class="<%= flash_alert_class(key) %> alert alert-dismissible" data-controller="alert">
+    <%= value %>
+    <button type="button" class="btn-close" data-action="alert#dismiss" aria-label="Close"></button>
+  </div>
+<% end %>
+<%= yield %>