daisyui 2.1.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75952f05719457c52d7085643cfeebc3b0dd2f72e4ddfc768d1ba7468431c161
-  data.tar.gz: 9029feca27ce0d586ad608c23170afcb7bafc1f17998af22793a2b39ce8c1ce3
+  metadata.gz: 6b5e9f54e5ef6670c715b8b23b7f25e2143b5dff828a17df64cd1c937cd8ea5a
+  data.tar.gz: 0ddd4bbef303e8fbbed5248317e107755cd96205ed8acb1e6b5e50b35505ad5c
 SHA512:
-  metadata.gz: 206f1d5f22c5ac7d41df14f1984fedfa70056b5128aa97ff3affb1bb5607cb6cfe1e7c92899c469b70e763976f5fa1c300fa9dcd18f3c10fd9dd10e41734af98
-  data.tar.gz: b65a346205a5fe198a858b3de5e191f20ee909fbe86c565e3d8aee87680ac9a1c2bf5ee681d6fdf698700063e271534ad766ac1afecfdf63ceb43557d03922b5
+  metadata.gz: f0f500a23192a07122b72795bb10c391ac5541d35ab6c5e168d73a8cac84070b46fbfd68de149c4fe4d2e01263c449c903c0172732a4b0245b0083f39f0f234f
+  data.tar.gz: d9f72b8aa71f1289efbfc83c7763fe3be6ce9e71b1a9b07ecf8a63c157228772031128eb665e2cf6eefe28c3f30119d5e03d19961f57c00ed88a76e1270b201a

data/CHANGELOG.md

@@ -1,5 +1,78 @@
 ## [Unreleased]
 
+### Fixed
+
+- The Tailwind sources generator accepts named groups and peers
+  (`group/item`, `group-has-[…]/item:block`, `peer-checked/field:block`) and a
+  plugin utility's named modifier (`motion-ease-in-out/opacity`) instead of
+  raising on them as paths. A bare word before the `/` (`app/components`) and a
+  second `/` (`lib/daisy_ui/base.rb`) are still rejected (#71).
+
+## [2.2.0] - 2026-10-26
+
+### Documentation for the variants API
+
+- Docs site: "Variants, states and slots" (when to use `variant`, `flag`,
+  `compound`, `state`/`on` and `slot`, the match values, render order and its
+  three pitfalls, introspection) and "Tailwind sources for your components"
+  (`--app`, the rake task, committing the file, the `stale?` spec, stylelint).
+- MCP server: `get_component` includes the component's `variants.schema`, and a
+  new `variants_guide` tool returns a short guide to the DSL with the pitfalls.
+- README: the variants section links the guide and lists the pitfalls.
+
+### Variants, states and slots
+
+A `variants` block declares what a component that owns its design needs
+beyond `register_modifiers`, as data the gem owns (#67). See the README's
+"Variants, states and slots".
+
+```ruby
+class Widget < DaisyUI::Button
+  variants do
+    base "font-medium"
+    default :size, :md
+    compound style: :outline, color: nil, class: "[--btn-bg:var(--color-base-100)]"
+    state :hover, "hover"
+    state :open, "[.dropdown:is(:focus-within,[open],:has(:popover-open))>&]"
+    on %i[hover open], style: %i[ghost link], class: "[--btn-bg:transparent]"
+  end
+end
+```
+
+- `variant` and `flag` are `register_modifiers` (groups, ClassMerge,
+  inheritance unchanged); `base` appends to the inherited base; `default`
+  applies when the caller names no member of a group.
+- `compound(**match, class:, set:)` adds classes when modifiers hold together
+  or one holds and another is absent (`color: nil`, `shape: [nil, :row]`,
+  `color: true`, flags `true`/`false`); `set:` selects members for the
+  caller's empty groups, in declaration order.
+- `state :name, "variant"` names a Tailwind variant once; `on(states, …)`
+  writes a declaration once and renders it under each state.
+- `slot :name, "classes"`, per-slot Hash values, and `slot_classes` /
+  `slot_options` for components with parts.
+- Defaults and `set:` members are resolved, not left to ClassMerge: a default
+  never renders beside the member the caller gave, with class merging off too.
+- A typo (a group, member, flag, state or slot the component does not have)
+  raises `ArgumentError` where it is declared.
+- `Component.variants.schema` returns plain, frozen data: variants, flags,
+  defaults, compounds, `on` rules, states and slots.
+- An unknown modifier's error now lists the component's groups:
+  `… has no modifier :huge. Variants: size: xs, sm, …`.
+- Registries are frozen by `DaisyUI.finalize!` like the others.
+
+### Tailwind sources for an app's own components
+
+State-prefixed classes appear nowhere literally in an app's source, so
+`bin/rails "daisyui:tailwind[app/assets/stylesheets/generated/daisyui_app.css]"`
+(or `daisyui-tailwind --app --require FILE`) writes `@source inline(…)` for
+every `DaisyUI::Base` subclass the app defines: its classes, compounds, slots
+and each `on` class per state. Sorted, versionless output meant to be
+committed; `DaisyUI::Tailwind.stale?(path)` fails a spec when a declaration
+changed and the file was not regenerated. From Ruby:
+`DaisyUI::Tailwind.sources(app: true)`.
+
+## [2.1.1] - 2026-10-17
+
 ### Tailwind sources for only the components an app uses
 
 `bundle exec daisyui-tailwind app -o app/assets/stylesheets/generated/daisyui.css`

data/README.md

@@ -216,6 +216,42 @@ language can read it directly from `$(bundle info daisyui --path)`:
 - `classes`: everything it can render: `name`, the modifiers and the class words in its Ruby. Words that are not classes cost nothing.
 - `shared`: base.rb's classes, which every component can render (`:skeleton`, the colour modifiers). Include them with any component.
 
+### Your own components (`--app`)
+
+A component you declare with [`variants`](#variants-states-and-slots) renders
+classes that appear nowhere literally in your source: an `on %i[hover open]`
+rule writes `hover:…` and `[.dropdown…>&]:…` at render time. Tailwind only
+compiles what it finds written out, so hand it your components' classes too:
+
+```sh
+bin/rails "daisyui:tailwind[app/assets/stylesheets/generated/daisyui_app.css]"
+# without Rails: load your components, then walk them
+bundle exec daisyui-tailwind --app --require ./config/components.rb -o app/assets/stylesheets/generated/daisyui_app.css
+```
+
+```css
+@import "./generated/daisyui.css";      /* the gem's components you use */
+@import "./generated/daisyui_app.css";  /* your own: variants, compounds, states, slots */
+```
+
+With the app loaded (the rake task eager-loads Rails), it walks every
+`DaisyUI::Base` subclass defined outside the gem and writes one
+`@source inline(…)` per component, sorted by name: its component class,
+modifiers, `base`, compound and slot classes, and each `on` class once per
+state. `--responsive` and `--prefix` work as above; `--format json` too. From
+Ruby: `DaisyUI::Tailwind.sources(app: true)`, or `app: [Widget, Picker]` for
+some. The header carries no version and nothing depends on the machine, so the
+file only changes when a declaration does: **commit it**, and let a spec fail
+when it is stale, the way this gem checks its own manifest:
+
+```ruby
+# spec/daisyui_tailwind_spec.rb
+it("has fresh Tailwind sources") { expect(DaisyUI::Tailwind.stale?("app/assets/stylesheets/generated/daisyui_app.css")).to be(false) }
+```
+
+`stale?` eager-loads a Rails app before it compares. The CSS build then never
+boots the app; it only imports the file.
+
 ## Class merging
 
 Components merge their classes so the last conflicting class wins, for Tailwind
@@ -306,6 +342,116 @@ end
 Keyword arguments are not validated: `Toggle(primray: true)` renders a
 `primray` attribute, because unknown keywords are HTML attributes.
 
+## Variants, states and slots
+
+The full guide, with when to use which declaration, is on the docs site:
+[Variants, states and slots](https://daisyui.phlex.fun/docs/variants). Four things
+to know before you write one:
+
+- A `default` renders after the caller's modifiers, so it beats one that sets the same property. Put such a value in `base`.
+- A `compound` or `on` rule also renders after the caller's modifiers. Leave the member it would override out of the match (`layout: [nil, :row]`).
+- `on` writes `"<state>:<class>"`, the state outermost. A rule that needs a child selector first (`[&_li]:hover:...`) stays literal in `base`.
+- `on` classes appear nowhere literally: generate [Tailwind sources](#your-own-components---app) for your components or Tailwind never compiles them.
+
+`register_modifiers` maps a symbol to classes. A component that owns its design
+also needs classes for two modifiers together, the same declarations under a
+browser state, and classes for its parts. Declare them in a `variants` block:
+
+```ruby
+class Widget < DaisyUI::Button
+  OPEN = "[.dropdown:is(:focus-within,[open],:has(:popover-open))>&]"
+
+  variants do
+    base "font-medium"                                        # after the inherited base (btn)
+    variant :size, sm: "btn-sm [--fontsize:var(--text-sm)]"  # overrides one inherited member
+    default :size, :md                                        # when the caller names no size
+
+    compound style: :outline, color: nil, class: "[--btn-bg:var(--color-base-100)]"
+    compound style: %i[ghost link], class: "[--btn-border:transparent]"
+
+    state :hover, "hover"
+    state :open, OPEN
+    on %i[hover open], style: %i[ghost link], class: "[--btn-bg:color-mix(in_oklab,var(--color-base-content)_8%,transparent)]"
+  end
+end
+
+Widget()            # btn font-medium btn-md
+Widget(:ghost, :sm) # btn font-medium btn-ghost btn-sm [--fontsize:…] [--btn-border:transparent]
+                    #   hover:[--btn-bg:…] [.dropdown…>&]:[--btn-bg:…]
+```
+
+| Declaration | |
+|---|---|
+| `variant :group, member: "classes", …` | Alternatives: the grouped `register_modifiers(group: { … })`. Members merge as one ClassMerge group. |
+| `flag :name, "classes"` | An on/off modifier: an ungrouped `register_modifiers` entry. `flag :name` alone is a `register_flags` flag, no class, for compounds to match. |
+| `base "classes"` | Classes every instance gets, appended to the inherited base. |
+| `default :group, :member` | The member used when the caller names none of the group. Never rendered beside a member the caller gives. |
+| `compound(**match, class:, set: {})` | `class:` when every key of `match` holds. `set: { group: :member }` selects members for the caller's empty groups; later compounds see them. Applied in order, after defaults. |
+| `state :name, "variant"` | Names a Tailwind variant once: `"hover"`, `"focus-visible"`, `"[.dropdown[open]>&]"`. |
+| `on(states, **match, class:)` | Like `compound`, with each class written once per state: `on %i[hover open], class: "a"` renders `hover:a [.dropdown…>&]:a`. |
+| `slot :name, "classes"` | A part of the component (see below). |
+
+A `match` value says when a group or flag holds:
+
+| Value | Holds when |
+|---|---|
+| `:member` | that member is selected: given, defaulted or set by an earlier compound |
+| `[:a, :b]` | any of them is; a `nil` in the list means "or none": `shape: [nil, :row]` |
+| `nil` / `false` | no member of the group is |
+| `true` | any member of the group is: `color: true` |
+| `true` / `false` | for a flag: it is on / off |
+
+Classes render in this order, merged by ClassMerge: the component class, `base`,
+the given modifiers, the defaulted and set members, compounds, `on` rules,
+`responsive:`, then `class:`. Every declared class goes through
+`DaisyUI.configuration.prefix` like a modifier (`hover:d-…` with `prefix = "d-"`).
+A typo fails where it is declared, at boot: a `compound`, `on`, `default` or
+`set:` naming a group, member, flag, state or slot the component does not have
+raises `ArgumentError`. `class` and `set` are reserved keys: a group called that could never be matched, and nothing stops you naming one.
+
+**Slots.** A component with parts declares each one; a variant, compound or `on`
+value can be a Hash keyed by slot (`root` is the component itself):
+
+```ruby
+class Picker < DaisyUI::Dropdown
+  variants do
+    slot :trigger
+    slot :menu, "mt-2"
+    variant :reach, wide: { root: "picker-wide", menu: "w-96" }
+    state :open, "[.dropdown:is(:focus-within,[open],:has(:popover-open))>&]"
+    on :open, class: { menu: "shadow-lg" }
+  end
+
+  def trigger(*mods, **options, &) = render DaisyUI::Button.new(*mods, **slot_options(:trigger, options), &)
+  def list(*mods, **options, &) = render DaisyUI::Menu.new(*mods, class: slot_classes(:menu, options), **options, &)
+end
+```
+
+`slot_classes(:menu, options)` returns the slot's classes, those of every
+selected member, compound and `on` rule for it, then `options.delete(:class)`,
+merged. `slot_options(:trigger, options)` returns `options` with that `class:`.
+
+**Introspection.** `Widget.variants.schema` is plain, frozen data for a docs
+page, a component gallery or a design-tool parity check:
+
+```ruby
+{
+  base: "btn font-medium",
+  variants: { style: %i[ghost link outline dash soft], size: %i[lg md xs xl sm], … }, # a re-declared member moves last
+  flags: %i[active disabled wide block],
+  defaults: { size: :md },
+  compounds: [{ match: { style: :outline, color: nil }, class: "[--btn-bg:…]", set: {} }, …],
+  on: [{ states: %i[hover open], match: { style: %i[ghost link] }, class: "[--btn-bg:…]" }],
+  states: { hover: "hover", open: "[.dropdown…>&]" },
+  slots: { root: "btn font-medium" }
+}
+```
+
+A component that only calls `register_modifiers` has a schema too (variants and
+flags). An unknown modifier's error names the groups:
+`Widget has no modifier :huge. Variants: style: ghost, link, outline, dash, soft; size: lg, md, xs, xl, sm; …`.
+The state-prefixed classes need [Tailwind sources of their own](#your-own-components---app).
+
 ## Threads, fibers and Ractors
 
 Components and `DaisyUI::ClassMerge` are safe to share between threads (Puma)
@@ -554,6 +700,9 @@ Add to your Claude Code MCP settings (`~/.claude.json` or project `.claude.json`
 - **list_components** - List all available DaisyUI components
 - **get_component** - Get detailed info about a specific component (modifiers, usage examples)
 - **search_components** - Search components by name or modifier
+- **variants_guide** - How to declare a component with `variants`: which declaration to use, the match values, render order and the pitfalls
+
+`get_component` also returns the component's variants schema (groups, flags, defaults, compounds, `on` rules, states and slots).
 
 # Usage
 

data/lib/daisy_ui/base.rb

@@ -35,6 +35,8 @@ module DaisyUI
   # This renders: <div class="[generated classes]" id="..." data-...="..." ...>
   #
   class Base < Phlex::HTML
+    include Variants::Rendering
+
     BOOLS = [true, false].freeze
     # Shared color modifiers used across multiple components
     # Maps color names to their DaisyUI background/text class combinations
@@ -145,6 +147,16 @@ module DaisyUI
         @component_class = Shareable.share(component_class)
       end
 
+      # What a `variants` block declared beyond modifiers: base, defaults,
+      # compounds, states, `on` rules and slots (see DaisyUI::Variants).
+      def variant_definitions
+        @variant_definitions || Variants::EMPTY
+      end
+
+      def variant_definitions=(definitions)
+        @variant_definitions = Shareable.share(definitions)
+      end
+
       # Positional symbols a component handles itself (e.g. Dropdown's
       # :popover): accepted as modifiers, but they emit no class.
       def flags
@@ -183,6 +195,7 @@ module DaisyUI
         subclass.modifiers = (modifiers || {}).dup
         subclass.modifier_groups = modifier_groups.transform_values(&:dup)
         subclass.flags = flags.dup
+        subclass.variant_definitions = variant_definitions
         # Inherit component_class if it was explicitly set
         return unless instance_variable_defined?(:@component_class)
 
@@ -216,11 +229,15 @@ module DaisyUI
         ClassMerge.reset!
       end
 
+      # Declares variants, compounds, defaults, states and slots; returns the
+      # declarations, so `Widget.variants.schema` describes them.
+      def variants(&) = Variants.build(self, &)
+
       # @api private Called by DaisyUI.finalize! for every component: derives
       # component_class on the main Ractor and makes sure every registry is
       # frozen for non-main Ractors.
       def finalize!
-        [component_class, modifiers, modifier_groups, flags].each { |registry| Shareable.share(registry) }
+        [component_class, modifiers, modifier_groups, flags, variant_definitions].each { |registry| Shareable.share(registry) }
         self
       end
     end
@@ -246,17 +263,20 @@ module DaisyUI
     # Main extension points - override these in your project!
 
     # Builds the final CSS class string from:
-    # 1. Component base class (e.g., "dropdown")
+    # 1. Component base class (e.g., "dropdown"), then a `variants` base
     # 2. Modifier classes (e.g., "dropdown-top")
-    # 3. Responsive classes (e.g., "sm:dropdown-hover")
-    # 4. User-provided classes via `class:` option
+    # 3. What a `variants` block derives: defaults, compounds, `on` states
+    # 4. Responsive classes (e.g., "sm:dropdown-hover")
+    # 5. User-provided classes via `class:` option
     #
     # Note: This method DESTRUCTIVELY removes :class from options
     # so it won't appear again in attributes
     def classes
       merge_classes(
         base_class,
+        variant_base_classes,
         *modifier_classes,
+        *variant_classes,
         *responsive_classes,
         options.delete(:class)
       )

data/lib/daisy_ui/engine.rb

@@ -11,6 +11,10 @@ module DaisyUI
   #   * appends the JS dir to the asset load path so Propshaft/Sprockets serve
   #     the .min.js and its sourcemap (Sprockets also needs them precompiled).
   #
+  # Rails also loads lib/tasks/daisyui.rake from here: `bin/rails
+  # daisyui:tailwind[OUTPUT]` writes the Tailwind sources of the app's own
+  # components (DaisyUI::Tailwind::AppSources).
+  #
   # The controllers are opt-in at the markup level (`Dropdown(:popover, stimulus:
   # true)`, `Tooltip(:popover)`) and not preloaded, so a page that never uses
   # one never fetches it.

data/lib/daisy_ui/mcp_server/variants_guide.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class McpServer
+    # The text of the `variants_guide` tool: the `variants` DSL on one page, with
+    # the three ways it surprises. Keep it in step with the README's "Variants,
+    # states and slots" and the docs site page.
+    module VariantsGuide
+      TEXT = <<~MARKDOWN
+        # Variants, states and slots
+
+        A component that owns its design declares it in a `variants` block on a
+        `DaisyUI::Base` subclass. `get_component` shows the result as a schema.
+
+        ```ruby
+        class Widget < DaisyUI::Button
+          variants do
+            base "font-medium"
+            variant :size, sm: "btn-sm", md: "btn-md"
+            default :size, :md
+            compound style: :outline, color: nil, class: "[--btn-bg:var(--color-base-100)]"
+            state :hover, "hover"
+            on :hover, style: %i[ghost link], class: "[--btn-bg:transparent]"
+          end
+        end
+        ```
+
+        ## Which declaration
+
+        | Need | Use |
+        |---|---|
+        | Alternatives, only one applies (sizes, colors) | `variant :group, member: "classes"` |
+        | An on/off modifier | `flag :name, "classes"`; `flag :name` alone has no class and exists to be matched |
+        | Classes every instance gets | `base "classes"` (appended to the inherited base) |
+        | A member when the caller names none of the group | `default :group, :member` |
+        | Classes when modifiers hold together or one is absent | `compound(**match, class:, set: {})` |
+        | The same classes under a browser state | `state :name, "<tailwind variant>"` once, then `on(states, **match, class:)` |
+        | A part of the component (trigger, menu) | `slot :name, "classes"`, then `slot_classes(name, options)` / `slot_options(name, options)` in the part's method |
+
+        ## Match values (`compound`, `on`)
+
+        | Value | Holds when |
+        |---|---|
+        | `:member` | that member is selected: given, defaulted or set by an earlier compound |
+        | `[:a, :b]` | any of them is; a `nil` in the list means "or none": `shape: [nil, :row]` |
+        | `nil` / `false` | no member of the group is |
+        | `true` | any member of the group is: `color: true` |
+        | `true` / `false` | for a flag: on / off |
+
+        `set: { group: :member }` on a compound selects a member for the caller's empty
+        groups; later compounds see it. `class` and `set` are reserved keys: a group called that could never be matched.
+        A `class:` or a modifier value can be a Hash keyed by slot (`root` is the component).
+
+        ## Render order
+
+        component class, `base`, the caller's modifiers, defaulted and set members,
+        compounds, `on` rules, `responsive:`, then the caller's `class:`. ClassMerge
+        resolves conflicts, the last one wins.
+
+        ## Pitfalls
+
+        1. A `default` renders after the caller's modifiers. A default member's class
+           beats a caller modifier that sets the same property (a default size's
+           `--fontsize` beats an `:inline` modifier's). Put a value both can set in
+           `base`, not in a default.
+        2. A compound or `on` rule also renders after the caller's modifiers, so it
+           can override a modifier's arbitrary property. Leave the conflicting member
+           out of the match (`layout: [nil, :inline, :row]`).
+        3. `on` writes `"<state>:<class>"`: the state prefix is outermost. A rule that
+           needs a child selector first (`[&_li]:hover:bg-...`) cannot be an `on :hover`
+           rule; keep it literal in `base`.
+
+        Also: do not name a group after an inherited one with a different meaning
+        (`Button` already has `shape`); a state selector with a child combinator puts `>`
+        in the class attribute, so parse rendered HTML with Nokogiri, not a regexp.
+
+        ## Tailwind sources
+
+        Tailwind v4 compiles only classes written out literally, and an `on` class is
+        written nowhere. Generate sources for your own components, commit the file,
+        import it from the Tailwind entry and fail a spec when it is stale:
+
+        ```sh
+        bin/rails "daisyui:tailwind[app/assets/stylesheets/generated/daisyui_app.css]"
+        bundle exec daisyui-tailwind --app --require ./config/components.rb -o app/assets/stylesheets/generated/daisyui_app.css
+        ```
+
+        ```ruby
+        expect(DaisyUI::Tailwind.stale?("app/assets/stylesheets/generated/daisyui_app.css")).to be(false)
+        ```
+
+        ## Introspection
+
+        `Widget.variants.schema` returns `base`, `variants`, `flags`, `defaults`,
+        `compounds`, `on`, `states` and `slots` as frozen data.
+      MARKDOWN
+    end
+  end
+end

data/lib/daisy_ui/mcp_server.rb

@@ -18,7 +18,7 @@ module DaisyUI
       },
       {
         name: "get_component",
-        description: "Get detailed information about a specific DaisyUI component including all modifiers and usage examples",
+        description: "Get detailed information about a specific DaisyUI component including all modifiers, its variants schema (groups, flags, defaults, compounds, on rules, states, slots) and usage examples",
         inputSchema: {
           type: "object",
           properties: {
@@ -37,6 +37,11 @@ module DaisyUI
           },
           required: ["query"]
         }
+      },
+      {
+        name: "variants_guide",
+        description: "How to declare a component's design with the variants DSL (variant, flag, default, compound, state/on, slot): when to use which, the match values, render order and the pitfalls",
+        inputSchema: { type: "object", properties: {}, required: [] }
       }
     ].freeze
     Shareable.make(TOOLS) # the Hashes inside too
@@ -113,6 +118,8 @@ module DaisyUI
         get_component(arguments["component"])
       when "search_components"
         search_components(arguments["query"])
+      when "variants_guide"
+        VariantsGuide::TEXT
       else
         return { content: [{ type: "text", text: "Unknown tool: #{tool_name}" }], isError: true }
       end
@@ -160,6 +167,14 @@ module DaisyUI
         ## Available Modifiers
         #{modifier_list.empty? ? 'No modifiers' : modifier_list}
 
+        ## Variants schema
+
+        Groups, flags, defaults, compounds, `on` rules, states and slots. `variants_guide` explains them.
+
+        ```json
+        #{JSON.pretty_generate(klass.variants.schema)}
+        ```
+
         ## Usage Examples
 
         ```ruby

data/lib/daisy_ui/tailwind/app_sources.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # The Tailwind sources for an app's own components (DaisyUI::Base
+    # subclasses outside the gem), read from their declarations rather than
+    # the gem's manifest: the component class, every modifier, and what a
+    # `variants` block declares, `on` rules written out once per state. Those
+    # state-prefixed classes appear nowhere literally in the app's source, so
+    # Tailwind only compiles them from here.
+    #
+    # One `@source inline(…)` per component, sorted by name, under a header
+    # with no version, so the file changes only when a declaration does: it
+    # is meant to be committed, and DaisyUI::Tailwind.stale? checks it.
+    class AppSources
+      HEADER = "/* Generated by daisyui-tailwind --app from the app's DaisyUI components: do not edit. */\n"
+
+      def initialize(components, responsive: [], prefix: nil)
+        anonymous = components.reject(&:name)
+        raise ArgumentError, "an anonymous class has no name to label its block: #{anonymous.inspect}" unless anonymous.empty?
+
+        @components = components.sort_by(&:name)
+        @breakpoints = responsive.map(&:to_s)
+        @prefix = prefix.to_s
+        Sources.validate_options!(@breakpoints, @prefix)
+      end
+
+      def render(format)
+        case format.to_s
+        when "css" then to_css
+        when "json" then to_json
+        else raise ArgumentError, "unknown format #{format.inspect}: css or json"
+        end
+      end
+
+      def to_css
+        return "#{HEADER}/* No app components. */\n" if @components.empty?
+
+        lines = @components.flat_map { |component| ["/* #{component.name} */", %(@source inline("#{classes(component).join(' ')}");)] }
+        "#{HEADER}#{lines.join("\n")}\n"
+      end
+
+      def to_json(*)
+        require "json"
+
+        components = @components.to_h do |component|
+          [component.name, { "name" => component.component_class&.to_s, "classes" => classes(component) }]
+        end
+        json = { "components" => components, "classes" => components.values.flat_map { |entry| entry["classes"] }.uniq.sort }
+        "#{JSON.pretty_generate(json)}\n"
+      end
+
+      private
+
+      def classes(component)
+        classes = component.variants.literal_classes(prefix: @prefix) + responsive_classes(component)
+        invalid = classes.reject { |token| Candidate.valid?(token) }
+        return classes.uniq.sort if invalid.empty?
+
+        raise ArgumentError, "#{component.name} declares #{invalid.map(&:inspect).join(', ')}, " \
+                             "which Tailwind cannot read from @source inline(…)"
+      end
+
+      # What `responsive:` renders: the component class and the modifiers.
+      def responsive_classes(component)
+        return [] if @breakpoints.empty?
+
+        tokens = [component.component_class&.to_s, *(component.modifiers || {}).values].compact.flat_map(&:split)
+        @breakpoints.flat_map { |breakpoint| tokens.map { |token| "#{breakpoint}:#{@prefix}#{token}" } }
+      end
+    end
+  end
+end

data/lib/daisy_ui/tailwind/candidate.rb

@@ -6,18 +6,24 @@ module DaisyUI
     # quoted string with brace expansion, and one unbalanced bracket in it
     # makes Tailwind drop every class after it, so a candidate starts and ends
     # like a utility or variant, has balanced () and [], and holds no quote,
-    # brace, semicolon, backslash or backtick. A `/` only introduces a
-    # fraction or an opacity (`w-1/2`, `bg-base-100/50`), never a path.
+    # brace, semicolon, backslash or backtick.
+    #
+    # A `/` before a digit or `[` is a fraction or an opacity (`w-1/2`,
+    # `bg-base-100/50`). A `/` before anything else is a path, except one
+    # trailing `/<name>` on a variant or utility: a named group or peer
+    # (`group/item`, `group-hover/item:underline`, `peer-checked/field:block`)
+    # or a plugin utility's named modifier (`motion-ease-in-out/opacity`).
     #
     # @api private
     module Candidate
       SHAPE = /\A[a-z@!\[*-][^\s"'`;{}\\]*[a-z0-9\])%!]\z/
       PATH = %r{/(?![0-9\[])}
+      NAMED = %r{\A(?<head>.+)/[A-Za-z0-9_-]+!?\z}
       CLOSING = { ")" => "(", "]" => "[" }.freeze
 
       class << self
         def valid?(token)
-          SHAPE.match?(token) && token.match?(/[a-z]/) && !PATH.match?(token) && balanced?(token)
+          SHAPE.match?(token) && token.match?(/[a-z]/) && balanced?(token) && !paths?(token)
         end
 
         # The candidates among the whitespace-separated words of `classes`.
@@ -38,6 +44,35 @@ module DaisyUI
           end
           open.empty?
         end
+
+        def paths?(token)
+          parts(token).any? { |part| path?(part) }
+        end
+
+        def path?(part)
+          return false unless PATH.match?(part)
+
+          head = part[NAMED, :head]
+          head.nil? || PATH.match?(head) || !named?(head)
+        end
+
+        # What may carry a `/<name>`: a group or a peer, or a utility with a
+        # `-` in it. A bare word (`app`, `vendor`, `hover`) is a directory.
+        def named?(head)
+          %w[group peer].include?(head) || (head.include?("-") && SHAPE.match?(head))
+        end
+
+        # The token split on its top-level `:`, as Tailwind splits variants
+        # from the utility; a `:` inside [] or () belongs to its part.
+        def parts(token)
+          depth = 0
+          slices = token.each_char.slice_when do |char, _|
+            depth += 1 if "[(".include?(char)
+            depth -= 1 if "])".include?(char)
+            char == ":" && depth.zero?
+          end
+          slices.map { |chars| chars.join.delete_suffix(":") }
+        end
       end
     end
   end