layered-resource-rails 0.1.0

data/app/controllers/layered/resource/resources_controller.rb

@@ -0,0 +1,20 @@
+module Layered
+  module Resource
+    # Default controller for `layered_resources` routes — inherits from the
+    # host app's ApplicationController so before_actions like Devise's
+    # `authenticate_user!` apply automatically. For an engine that needs
+    # the engine's own ApplicationController (and its authorize block),
+    # define a sibling controller and include the concern:
+    #
+    #   class Layered::Assistant::ResourcesController < Layered::Assistant::ApplicationController
+    #     include Layered::Resource::Controller
+    #   end
+    #
+    # `layered_resources` routes will auto-detect a namespaced controller
+    # by name when a `namespace:` option is given (or inferred from the
+    # surrounding routes module scope).
+    class ResourcesController < ::ApplicationController
+      include Controller
+    end
+  end
+end

data/app/helpers/layered/resource/filters_helper.rb

@@ -0,0 +1,321 @@
+module Layered
+  module Resource
+    # View plumbing for the index filter bar. Filters are plain Ransack
+    # predicates in the query string, so "applying" a filter is just a GET to
+    # the collection path with the current `q` params plus/minus the filter's
+    # own keys. Select-type controls apply instantly via links; range and
+    # multi-select controls are small GET forms whose hidden fields round-trip
+    # every *other* `q` param (search term, sort, other filters) so nothing is
+    # lost across submits — no JavaScript involved.
+    #
+    # Picking a filter from the "Add filter" menu doesn't set a value — it
+    # adds the filter as an *unset* tag whose popover holds the controls.
+    # The top-level `f[]` param records which tags the user added and in
+    # what order (new tags join the end of the row); it round-trips through
+    # every link and form like the `q` params do and lives as long as the
+    # tag does — setting a value keeps it, only the tag's ✕ removes it.
+    module FiltersHelper
+      BOOLEAN_FILTER_COLLECTION = [["Yes", "true"], ["No", "false"]].freeze
+
+      def layered_filters
+        @_layered_filters ||= @resource.resolved_filters
+      end
+
+      # The Ransack param scope this page's search object nests under
+      # (virtually always "q").
+      def layered_filter_scope
+        ((@q && @q.context&.search_key) || :q).to_s
+      end
+
+      # The current same-scope Ransack params as a plain string-keyed hash —
+      # the working state that apply/remove URLs and hidden fields are built
+      # from. Values are the raw request strings/arrays.
+      def layered_filter_query_params
+        raw = params[layered_filter_scope]
+        return {} unless raw.respond_to?(:to_unsafe_h)
+
+        raw.to_unsafe_h.stringify_keys.transform_values { |v| layered_filter_normalize_value(v) }
+      end
+
+      # The `q` keys a filter owns, e.g. ["status_eq"], ["user_id_in"], or
+      # ["created_at_gteq", "created_at_lteq"] for a range.
+      def layered_filter_param_keys(filter)
+        filter[:param_keys]
+      end
+
+      def layered_filter_active?(filter)
+        layered_filter_param_keys(filter).any? { |k| layered_filter_query_params[k].present? }
+      end
+
+      # Declared filters added via the "Add filter" menu, in the order they
+      # were added (`f[]` in the query string) — set or not, this is the
+      # tag row's ordering. Unknown or stale entries are dropped.
+      def layered_added_filter_attributes
+        declared = layered_filters.map { |f| f[:attribute].to_s }
+        Array(params[:f]).map(&:to_s).uniq & declared
+      end
+
+      def layered_filter_pending?(filter)
+        !layered_filter_active?(filter) &&
+          layered_added_filter_attributes.include?(filter[:attribute].to_s)
+      end
+
+      # URL the "Add filter" menu links to: current params plus this filter
+      # as an unset tag at the end of the row. The `fo` param asks that
+      # render to open the new tag's popover, so the controls are ready
+      # without a second click.
+      def layered_filter_add_path(filter)
+        attribute = filter[:attribute].to_s
+        layered_filter_path_with(layered_filter_query_params,
+                                 layered_added_filter_attributes | [attribute],
+                                 open: attribute)
+      end
+
+      # The filter whose tag popover should open on this render (via the
+      # tag popover's `open:` option) — the one-shot `fo` param carried only
+      # by the "Add filter" menu links. Unlike `q` and `f[]` it never
+      # round-trips: forms and links rebuild their URLs without it and the
+      # pagy call strips it from page links, so the popover opens once and
+      # stays closed thereafter.
+      def layered_auto_open_filter
+        layered_filters.find { |f| f[:attribute].to_s == params[:fo] } if params[:fo].present?
+      end
+
+      def layered_filter_label(filter)
+        filter[:label] || @resource.model.human_attribute_name(filter[:attribute])
+      end
+
+      # Resolved [label, value] option pairs for select-type controls. Values
+      # are strings so they compare directly against request params. Accepts
+      # a collection as an array of values, [label, value] pairs, a callable,
+      # or records (from a callable or a belongs_to's default klass.all).
+      def layered_filter_collection(filter)
+        return BOOLEAN_FILTER_COLLECTION if filter[:as] == :boolean
+
+        # Memoised per render: a callable collection (or a belongs_to's default
+        # `klass.all`) is a query, and the control, the size check behind
+        # `layered_filter_control`, and the tag text all ask for it.
+        @_layered_filter_collections ||= {}
+        @_layered_filter_collections[filter[:attribute]] ||= begin
+          raw = filter[:collection]
+          raw = raw.call if raw.respond_to?(:call)
+          raw ||= filter[:reflection]&.klass&.all
+          Array(raw).map do |entry|
+            if entry.is_a?(Array)
+              [entry.first.to_s, entry.last.to_s]
+            elsif entry.respond_to?(:to_key)
+              [layered_filter_record_label(entry), entry.id.to_s]
+            else
+              [entry.to_s, entry.to_s]
+            end
+          end
+        end
+      end
+
+      # The control this filter actually renders — `filter[:as]` for everything
+      # but a select, which resolves between the plain list and the combobox.
+      # The choice is made here rather than in `resolved_filters` because it
+      # depends on how many options the collection turns out to hold, and a
+      # callable collection only resolves per request.
+      #
+      # A `url:` filter is always a combobox (its options are fetched as the
+      # user types, so there is nothing to render up front and nothing to
+      # count); a declared `as:` is honoured as declared; otherwise a list
+      # longer than `Layered::Resource.filter_combobox_threshold` switches to
+      # the combobox, since neither a checkbox list nor a menu of links scales.
+      def layered_filter_control(filter)
+        return filter[:as] unless Layered::Resource::Base::SELECT_FILTER_CONTROLS.include?(filter[:as])
+        return :combobox if filter[:as] == :combobox || filter[:url].present?
+        return :select if filter[:as_declared]
+
+        layered_filter_collection(filter).size > Layered::Resource.filter_combobox_threshold ? :combobox : :select
+      end
+
+      # A filter's `url:`, resolved in the view so it can be given as a
+      # callable wrapping a path helper (`-> { options_users_path }`) — the
+      # form a resource class can write without route helpers at load time.
+      def layered_filter_url(filter)
+        url = filter[:url]
+        url.respond_to?(:call) ? instance_exec(&url) : url
+      end
+
+      # The `l_ui_combobox` options for a filter rendered as a combobox:
+      # remote (`url:`) or local (`collection:`), never both, plus whatever
+      # combobox options the filter declared. Selections go over as
+      # [label, value] pairs because a remote combobox has no collection in
+      # the browser to look a label up in.
+      def layered_filter_combobox_options(filter)
+        options = {
+          label: layered_filter_label(filter),
+          multiple: !!filter[:multiple],
+          selected: layered_filter_selected_options(filter)
+        }
+        if (url = layered_filter_url(filter)).present?
+          options[:url] = url
+        else
+          options[:collection] = layered_filter_collection(filter)
+        end
+        options[:min_chars] = filter[:min_chars] if filter[:min_chars]
+        options[:text] = filter[:text] if filter[:text]
+        options
+      end
+
+      # The filter's current values as [label, value] pairs — the combobox's
+      # selections and the tag's text come from the same place, so they always
+      # agree. Labels come from the collection when there is one; a remote
+      # filter has none, so an association's are read from the records
+      # themselves and anything else shows the raw value.
+      def layered_filter_selected_options(filter)
+        values = Array(layered_filter_query_params[layered_filter_param_keys(filter).first])
+                   .map(&:to_s).reject(&:blank?)
+        return [] if values.empty?
+
+        labels = layered_filter_option_labels(filter, values)
+        values.map { |value| [labels.fetch(value, value), value] }
+      end
+
+      def layered_filter_selected?(filter, value)
+        current = layered_filter_query_params[layered_filter_param_keys(filter).first]
+        Array(current).map(&:to_s).include?(value.to_s)
+      end
+
+      # URL applying `value` for a single-select/boolean filter, keeping every
+      # other `q` param and dropping pagination. The filter's `f[]` entry is
+      # kept — it holds the tag's position in the row.
+      def layered_filter_apply_path(filter, value)
+        q = layered_filter_query_params.except(*layered_filter_param_keys(filter))
+        q[layered_filter_param_keys(filter).first] = value
+        layered_filter_path_with(q)
+      end
+
+      # URL with the filter's own params (and pending `f[]` entry) stripped —
+      # the tag's ✕ and the controls' Clear links. A filter with a `default:`
+      # writes explicit blanks instead of dropping its keys: an absent key
+      # would just re-apply the default on the next request.
+      def layered_filter_remove_path(filter)
+        q = layered_filter_query_params
+        if filter[:default].nil?
+          q = q.except(*layered_filter_param_keys(filter))
+        else
+          layered_filter_param_keys(filter).each { |k| q[k] = "" }
+        end
+        layered_filter_path_with(q, layered_added_filter_attributes - [filter[:attribute].to_s])
+      end
+
+      # Tag text, e.g. "Status: Published", "User: Alice, Bob",
+      # "Created at: 2026-01-01 – 2026-06-30", "Comments count: ≥ 5".
+      def layered_filter_tag_text(filter)
+        "#{layered_filter_label(filter)}: #{layered_filter_tag_value(filter)}"
+      end
+
+      # Hidden inputs carrying every same-scope `q` param except the given
+      # filter's own keys (and `except:` extras), plus all the `f[]` entries
+      # (including the submitting filter's own — it keeps the tag's position),
+      # so a form's GET submit preserves the search term, sort, the other
+      # filters, and the tag row's order.
+      def layered_filter_hidden_fields(filter = nil, except: [])
+        skip = (filter ? layered_filter_param_keys(filter) : []) + Array(except).map(&:to_s)
+        scope = layered_filter_scope
+
+        fields = layered_filter_query_params.flat_map do |key, value|
+          next [] if skip.include?(key) || value.is_a?(Hash)
+
+          name = value.is_a?(Array) ? "#{scope}[#{key}][]" : "#{scope}[#{key}]"
+          Array(value).map { |v| hidden_field_tag(name, v, id: nil) }
+        end
+
+        fields += layered_added_filter_attributes.map { |attr| hidden_field_tag("f[]", attr, id: nil) }
+
+        safe_join(fields)
+      end
+
+      # The combined Ransack key the search box posts, mirroring
+      # l_ui_search_form's simple mode (`:cont` predicate, `:or` combinator).
+      def layered_search_field_key
+        @resource.search_fields.map(&:to_s).join("_or_") + "_cont"
+      end
+
+      # Clear link for the search box that drops only the search term,
+      # keeping active filters and sort.
+      def layered_search_clear_path
+        layered_filter_path_with(layered_filter_query_params.except(layered_search_field_key))
+      end
+
+      # The collection path carrying the full current state (`q` and `f[]`),
+      # minus pagination. Links that rebuild their query from a base URL —
+      # the table's sort links replace only `q[s]` on it — must start from
+      # this, not the bare collection path, or they drop search and filters.
+      def layered_filtered_collection_path
+        layered_filter_path_with(layered_filter_query_params)
+      end
+
+      private
+
+      def layered_filter_path_with(q, added = layered_added_filter_attributes, open: nil)
+        query = {}
+        query[layered_filter_scope] = q if q.present?
+        query[:f] = added if added.present?
+        query[:fo] = open if open.present?
+        path = layered_collection_path
+        query.present? ? "#{path}?#{query.to_query}" : path
+      end
+
+      def layered_filter_tag_value(filter)
+        case filter[:as]
+        when :select, :combobox, :boolean
+          layered_filter_selected_options(filter).map(&:first).join(", ")
+        when :date_range, :range
+          from_key, to_key = layered_filter_param_keys(filter)
+          from = layered_filter_query_params[from_key]
+          to = layered_filter_query_params[to_key]
+          if from.present? && to.present?
+            "#{from} – #{to}"
+          elsif from.present?
+            "≥ #{from}"
+          else
+            "≤ #{to}"
+          end
+        else
+          layered_filter_query_params[layered_filter_param_keys(filter).first]
+        end
+      end
+
+      # Value => label for the filter's currently-set values. A remote filter
+      # has no collection to read them from, so an association's are looked up
+      # by id; anything else (a remote filter over a plain column) resolves to
+      # nothing and the value stands in for its own label.
+      def layered_filter_option_labels(filter, values)
+        if filter[:url].present?
+          reflection = filter[:reflection]
+          return {} if reflection.nil?
+
+          reflection.klass.where(id: values)
+                    .to_h { |record| [record.id.to_s, layered_filter_record_label(record)] }
+        else
+          layered_filter_collection(filter).to_h { |label, value| [value, label] }
+        end
+      end
+
+      # Drops the blank value a combobox posts ahead of its selections (there
+      # so that clearing every token submits an empty collection rather than
+      # omitting the parameter — Ransack prunes it from the query itself). An
+      # array left with nothing becomes an explicit blank, the same shape the
+      # Clear link writes, so a cleared filter reads as inactive and a
+      # `default:` doesn't immediately re-apply.
+      def layered_filter_normalize_value(value)
+        return value unless value.is_a?(Array)
+
+        pruned = value.reject(&:blank?)
+        pruned.empty? ? "" : pruned
+      end
+
+      # Label for a record in a belongs_to select when no `collection:` is
+      # given. The associated model is another resource's business, not this
+      # one's, so there is no `label_attribute` to ask for: the shared
+      # fallbacks (name/title/label/email, else "Model #id") do the labelling.
+      def layered_filter_record_label(record)
+        Layered::Resource.record_label(record)
+      end
+    end
+  end
+end

data/app/views/layered/resource/columns/_badge.html.erb

@@ -0,0 +1,2 @@
+<% variant = (!value.nil? && options.fetch(:variants, {})[value.to_s.to_sym]) || :default %>
+<span class="l-ui-badge l-ui-badge--<%= variant %><%= " l-ui-badge--rounded" if options[:rounded] %>"><%= value %></span>

data/app/views/layered/resource/columns/_boolean.html.erb

@@ -0,0 +1 @@
+<%= value ? options.fetch(:true_label, "✓") : options.fetch(:false_label, "✗") %>

data/app/views/layered/resource/columns/_datetime.html.erb

@@ -0,0 +1 @@
+<%= value&.strftime(options[:format] || "%-d %b %Y %H:%M") %>

data/app/views/layered/resource/columns/_text.html.erb

@@ -0,0 +1 @@
+<%= value.respond_to?(:strftime) ? value.strftime("%-d %b %Y %H:%M") : value %>

data/app/views/layered/resource/resources/_filter_control.html.erb

@@ -0,0 +1,87 @@
+<%# One filter's editing UI, rendered inside its tag's popover.
+    Short single-selects and booleans apply instantly via links; multi-selects,
+    comboboxes, ranges, and text filters are GET forms whose hidden fields
+    round-trip every other q param (search, sort, other filters) and the other
+    unset tags' f[] entries, so submits compose.
+
+    `layered_filter_control` — not `filter[:as]` — decides which control a
+    select renders as: a long option list (or a remote `url:` one) becomes a
+    type-ahead combobox, which needs the form even when single-choice. %>
+<% scope = layered_filter_scope
+   control = layered_filter_control(filter)
+   active = layered_filter_active?(filter)
+   frame_data = { turbo_frame: turbo_frame_name, turbo_action: "advance" } %>
+
+<% if [:select, :boolean].include?(control) && !filter[:multiple] %>
+  <div class="l-ui-popover__menu">
+    <% layered_filter_collection(filter).each do |label, value| %>
+      <% selected = layered_filter_selected?(filter, value) %>
+      <%= link_to layered_filter_apply_path(filter, value),
+            class: "l-ui-popover__menu-item",
+            aria: (selected ? { current: true } : {}),
+            data: frame_data do %>
+        <%= label %><%= " ✓" if selected %>
+      <% end %>
+    <% end %>
+    <% if active %>
+      <hr class="l-ui-popover__menu-divider">
+      <%= link_to "Clear", layered_filter_remove_path(filter),
+            class: "l-ui-popover__menu-item l-ui-popover__menu-item--danger", data: frame_data %>
+    <% end %>
+  </div>
+<% else %>
+  <%= form_with url: layered_collection_path, method: :get,
+        class: "l-ui-form", data: frame_data do %>
+    <%= layered_filter_hidden_fields(filter) %>
+
+    <% if control == :combobox %>
+      <%# The combobox names the bare key: it appends its own `[]` when
+          multiple, so a single-choice one posts a scalar the `eq` predicate
+          can use. Its leading blank hidden value means clearing every token
+          and applying submits an empty filter rather than omitting the key. %>
+      <% key = layered_filter_param_keys(filter).first %>
+      <%= l_ui_combobox("#{scope}[#{key}]",
+            id: "layered-filter-#{@layered_route_key}-#{filter[:attribute]}-combobox",
+            **layered_filter_combobox_options(filter)) %>
+    <% elsif control == :select %>
+      <% key = layered_filter_param_keys(filter).first %>
+      <% layered_filter_collection(filter).each_with_index do |(label, value), index| %>
+        <%# The wrapping label makes the whole row toggle the checkbox, so the
+            row gets the pointer too (no l-ui class carries just a cursor). %>
+        <label class="l-ui-checkbox-container <%= index.zero? ? "l-ui-mt-0" : "l-ui-mt-3" %>" style="cursor: pointer">
+          <%= check_box_tag "#{scope}[#{key}][]", value,
+                layered_filter_selected?(filter, value), id: nil, class: "l-ui-checkbox" %>
+          <span class="l-ui-checkbox-container__label"><%= label %></span>
+        </label>
+      <% end %>
+    <% elsif [:date_range, :range].include?(filter[:as]) %>
+      <% from_key, to_key = layered_filter_param_keys(filter) %>
+      <% field_tag = filter[:as] == :date_range ? :date_field_tag : :number_field_tag %>
+      <% field_options = filter[:as] == :range ? { step: "any" } : {} %>
+      <label>
+        From
+        <%= send(field_tag, "#{scope}[#{from_key}]", layered_filter_query_params[from_key],
+              { id: nil, class: "l-ui-form__field" }.merge(field_options)) %>
+      </label>
+      <label class="l-ui-form__group">
+        To
+        <%= send(field_tag, "#{scope}[#{to_key}]", layered_filter_query_params[to_key],
+              { id: nil, class: "l-ui-form__field" }.merge(field_options)) %>
+      </label>
+    <% else %>
+      <% key = layered_filter_param_keys(filter).first %>
+      <label>
+        Contains
+        <%= text_field_tag "#{scope}[#{key}]", layered_filter_query_params[key],
+              id: nil, class: "l-ui-form__field" %>
+      </label>
+    <% end %>
+
+    <hr class="l-ui-popover__menu-divider l-ui-mt-3">
+    <%= button_tag "Apply", name: nil, class: "l-ui-popover__menu-item" %>
+    <% if active %>
+      <%= link_to "Clear", layered_filter_remove_path(filter),
+            class: "l-ui-popover__menu-item l-ui-popover__menu-item--danger", data: frame_data %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/layered/resource/resources/_filters.html.erb

@@ -0,0 +1,60 @@
+<%# The filter bar. Picking a filter from the "Add filter" popover adds it as
+    an unset tag (tracked by the f[] param) with its popover already open,
+    ready to take a value; pressing a tag's label reopens the popover, and
+    its ✕ removes it. Once a value is set the tag persists via its own q
+    params and the f[] entry drops away. The bar lives inside the index turbo
+    frame, so adding, applying, changing, or removing a filter is a single
+    frame navigation that reloads the table and re-renders the tags. %>
+<%# Tag order: pinned first (declaration order), then filters active straight
+    from the URL (e.g. a bookmarked query), then user-added tags in the order
+    they were added (the f[] list) — so a new tag always joins the end. %>
+<% pinned, unpinned = layered_filters.partition { |f| f[:pinned] }
+   added = layered_added_filter_attributes
+   tags = pinned +
+          unpinned.select { |f| layered_filter_active?(f) && !added.include?(f[:attribute].to_s) } +
+          added.filter_map { |attr| unpinned.find { |f| f[:attribute].to_s == attr } }
+   available = layered_filters - tags %>
+
+<div class="l-ui-mt-3 l-ui-tag-row">
+  <% tags.each do |filter| %>
+    <%= l_ui_tag do |t| %>
+      <% t.button(aria: { label: "Edit #{layered_filter_label(filter)} filter" }) do %>
+        <%= layered_filter_active?(filter) ? layered_filter_tag_text(filter) : layered_filter_label(filter) %>
+      <% end %>
+      <%# A pinned tag is always shown, so it has no remove ✕ — its popover's
+          Clear resets the value but the tag stays. %>
+      <% unless filter[:pinned] %>
+        <% t.remove layered_filter_remove_path(filter),
+             aria: { label: "Remove #{layered_filter_label(filter)} filter" },
+             data: { turbo_frame: turbo_frame_name, turbo_action: "advance" } %>
+      <% end %>
+      <%# `open` renders a freshly added tag (the one-shot `fo` param from the
+          add-filter link) with its popover already open, ready for a value. %>
+      <% t.popover id: "layered-filter-#{@layered_route_key}-#{filter[:attribute]}",
+                   open: filter == layered_auto_open_filter do %>
+        <%= render "filter_control", filter: filter, turbo_frame_name: turbo_frame_name %>
+      <% end %>
+    <% end %>
+  <% end %>
+
+  <% if available.any? %>
+    <%= l_ui_popover do |p| %>
+      <% p.trigger(class: "l-ui-button l-ui-button--outline l-ui-button--small") do %>
+        <%# Inline plus (stroke follows the button's text colour) — a text "+"
+            is capped at the button's text-xs and reads too small. %>
+        <svg class="l-ui-icon--xs" fill="none" stroke="currentColor" stroke-width="2"
+             viewBox="0 0 24 24" aria-hidden="true">
+          <path stroke-linecap="round" stroke-linejoin="round" d="M12 5v14M5 12h14" />
+        </svg>
+        Add filter
+      <% end %>
+      <div class="l-ui-popover__menu">
+        <% available.each do |filter| %>
+          <%= link_to layered_filter_label(filter), layered_filter_add_path(filter),
+                class: "l-ui-popover__menu-item",
+                data: { turbo_frame: turbo_frame_name, turbo_action: "advance" } %>
+        <% end %>
+      </div>
+    <% end %>
+  <% end %>
+</div>

data/app/views/layered/resource/resources/edit.html.erb

@@ -0,0 +1,16 @@
+<div class="l-ui-spread">
+  <div>
+    <%= l_ui_breadcrumbs do %>
+      <% layered_breadcrumbs.each do |crumb| %>
+        <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+      <% end %>
+      <%= l_ui_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+    <% end %>
+
+    <h1 class="l-ui-heading">Edit <%= @model.model_name.human.downcase %></h1>
+  </div>
+</div>
+
+<div class="l-ui-mt-2">
+  <%= l_ui_form(@record, fields: @fields, url: @form_url, method: :patch) %>
+</div>

data/app/views/layered/resource/resources/index.html.erb

@@ -0,0 +1,106 @@
+<% turbo_frame_name = "layered_#{@layered_route_key}" %>
+
+<div class="l-ui-spread">
+  <div>
+    <% if layered_breadcrumbs.any? %>
+      <%= l_ui_breadcrumbs do %>
+        <% layered_breadcrumbs.each do |crumb| %>
+          <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+        <% end %>
+      <% end %>
+    <% end %>
+
+    <h1 class="l-ui-heading">
+      <%= @model.model_name.human.pluralize %>
+    </h1>
+  </div>
+
+  <% if resource_can?(:new) %>
+    <%= link_to "New",
+          layered_collection_path(action: :new),
+          class: "l-ui-button l-ui-button--primary" %>
+  <% end %>
+</div>
+
+<% introduction_partial = "layered/#{@layered_resource_name}/introduction" %>
+<% if lookup_context.exists?(introduction_partial, [], true) %>
+  <%= render introduction_partial %>
+<% end %>
+
+<%= turbo_frame_tag turbo_frame_name, data: { turbo_action: "advance" } do %>
+  <% if @resource.search_fields.any? %>
+    <div class="l-ui-mt-4">
+      <% if layered_filters.any? %>
+        <%# With filters declared, the search form must round-trip the active
+            filter and sort q params as hidden fields so its submit composes
+            with them; Clear drops only the search term. %>
+        <%= l_ui_search_form(@q, url: layered_collection_path, turbo_frame: turbo_frame_name) do |f| %>
+          <%= layered_filter_hidden_fields(except: layered_search_field_key) %>
+          <%= f.label layered_search_field_key, "Search", class: "l-ui-sr-only" %>
+          <div class="l-ui-search-inline">
+            <%= f.text_field layered_search_field_key,
+                  class: "l-ui-form__field", placeholder: @resource.search_placeholder %>
+            <%= f.submit "Search", class: "l-ui-button l-ui-button--primary" %>
+            <%= link_to "Clear", layered_search_clear_path,
+                  class: "l-ui-button l-ui-button--outline",
+                  data: { turbo_frame: turbo_frame_name, turbo_action: "advance" } %>
+          </div>
+        <% end %>
+      <% else %>
+        <%= l_ui_search_form(@q,
+              url: layered_collection_path,
+              fields: @resource.search_fields,
+              placeholder: @resource.search_placeholder,
+              clear: true,
+              turbo_frame: turbo_frame_name) %>
+      <% end %>
+    </div>
+  <% end %>
+
+  <% if layered_filters.any? %>
+    <%= render "filters", turbo_frame_name: turbo_frame_name %>
+  <% end %>
+
+  <% actions_proc = if @resource_can_edit || @resource_can_destroy
+    ->(record) do
+      items = []
+      if resource_can?(:edit, record)
+        items << link_to("Edit", layered_member_path(record, action: :edit),
+                  class: "l-ui-popover__menu-item",
+                  data: { turbo_frame: "_top" })
+      end
+      if resource_can?(:destroy, record)
+        items << tag.hr(class: "l-ui-popover__menu-divider") if items.any?
+        items << button_to("Delete", layered_member_path(record),
+                    method: :delete,
+                    class: "l-ui-popover__menu-item l-ui-popover__menu-item--danger",
+                    data: { turbo_confirm: "Are you sure?", turbo_frame: "_top" })
+      end
+      next if items.empty?
+
+      l_ui_popover(align: :end) do |p|
+        p.trigger(class: "l-ui-button l-ui-button--outline l-ui-button--icon l-ui-button--small",
+                  aria: { label: "Actions for #{layered_record_label(record)}" }) do
+          image_tag("layered_ui/icon_more.svg", alt: "",
+            class: "l-ui-icon l-ui-icon--sm", aria: { hidden: true })
+        end
+        tag.div(safe_join(items), class: "l-ui-popover__menu")
+      end
+    end
+  end %>
+
+  <div class="l-ui-mt-4">
+    <%# The sort links rebuild their query from this base URL, so it must
+        carry the current search, filters, and unset tags. %>
+    <%= l_ui_table(@records,
+          columns: @columns,
+          caption: @layered_route_key.humanize,
+          query: @q,
+          url: layered_filtered_collection_path,
+          actions: actions_proc,
+          floating_actions: true,
+          turbo_frame: turbo_frame_name) %>
+
+    <%= l_ui_pagy(@pagy) %>
+  </div>
+<% end %>

data/app/views/layered/resource/resources/new.html.erb

@@ -0,0 +1,16 @@
+<div class="l-ui-spread">
+  <div>
+    <%= l_ui_breadcrumbs do %>
+      <% layered_breadcrumbs.each do |crumb| %>
+        <%= l_ui_breadcrumb_item crumb[:label], crumb[:path] %>
+      <% end %>
+      <%= l_ui_breadcrumb_item @model.model_name.human.pluralize, layered_collection_path %>
+    <% end %>
+
+    <h1 class="l-ui-heading">New <%= @model.model_name.human.downcase %></h1>
+  </div>
+</div>
+
+<div class="l-ui-mt-2">
+  <%= l_ui_form(@record, fields: @fields, url: @form_url) %>
+</div>