daisyui 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75952f05719457c52d7085643cfeebc3b0dd2f72e4ddfc768d1ba7468431c161
-  data.tar.gz: 9029feca27ce0d586ad608c23170afcb7bafc1f17998af22793a2b39ce8c1ce3
+  metadata.gz: b1bf5647c845ed4fbdf7d538e4934c7171b23039cbc9029d8c68330b82f0acd2
+  data.tar.gz: 9282c494a1db396b4153fda3c9696040e8c95ac7d495d0bbcf9a0be983a49fb1
 SHA512:
-  metadata.gz: 206f1d5f22c5ac7d41df14f1984fedfa70056b5128aa97ff3affb1bb5607cb6cfe1e7c92899c469b70e763976f5fa1c300fa9dcd18f3c10fd9dd10e41734af98
-  data.tar.gz: b65a346205a5fe198a858b3de5e191f20ee909fbe86c565e3d8aee87680ac9a1c2bf5ee681d6fdf698700063e271534ad766ac1afecfdf63ceb43557d03922b5
+  metadata.gz: f2fa7469a01b18c4bb28110ab4da1238ce8c846fef910e3edc488d283ed641e8cee5fb3b2fb69ca528f643283a1339114db14354a0f3d0d306b67f996923e4d8
+  data.tar.gz: 282f9add88cc7e82eabd013b81bb4e1470c8809f6687ada460470ef97a472d228182154f644c56a7df000f4714dd8d51eca4bbc5692f5ddbbdba7607e84617f4

data/CHANGELOG.md

@@ -1,5 +1,68 @@
 ## [Unreleased]
 
+### 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/command.rb

@@ -13,6 +13,10 @@ module DaisyUI
         that the Ruby and templates under each PATH use, plus the components those
         render. @import the output from your Tailwind entry.
 
+        With --app, prints the sources of the app's own components (DaisyUI::Base
+        subclasses, after requiring each --require FILE) instead: their variants,
+        compounds and state-prefixed classes, for a file you commit.
+
       TEXT
 
       def self.run(argv, out: $stdout, err: $stderr) = new(out:, err:).run(argv)
@@ -25,16 +29,16 @@ module DaisyUI
       def run(argv)
         require "optparse"
 
-        options = { components: [], format: "css", responsive: [] }
+        options = { components: [], format: "css", responsive: [], require: [] }
         parser = parser(options)
         paths = parser.parse(argv)
         return help(parser) if options[:help]
-        return usage(parser) if paths.empty? && options[:components].empty?
+        return usage(parser) if paths.empty? && options[:components].empty? && !options[:app]
 
-        result = Tailwind.sources(scan: paths, **options.slice(:components, :format, :responsive, :prefix))
+        result = Tailwind.sources(scan: paths, **sources_options(options))
         options[:output] ? write(options[:output], result) : @out.write(result)
         0
-      rescue OptionParser::ParseError, ArgumentError, SystemCallError => e
+      rescue OptionParser::ParseError, ArgumentError, SystemCallError, LoadError => e
         @err.puts "daisyui-tailwind: #{e.message}"
         1
       end
@@ -53,10 +57,23 @@ module DaisyUI
             options[:responsive].concat(breakpoints)
           end
           opts.on("--prefix PREFIX", "The DaisyUI.configuration.prefix your app sets") { |prefix| options[:prefix] = prefix }
+          opts.on("--app", "The app's own components instead of the gem's") { options[:app] = true }
+          opts.on("-r", "--require FILE", "With --app: load FILE first, e.g. config/environment.rb (repeatable)") do |file|
+            options[:require] << file
+          end
           opts.on("-h", "--help", "Show this help") { options[:help] = true }
         end
       end
 
+      # With --app: load the app's files, then freeze DaisyUI as boot does.
+      def sources_options(options)
+        if options[:app]
+          options[:require].each { |file| require File.expand_path(file) }
+          DaisyUI.finalize!
+        end
+        options.slice(:components, :format, :responsive, :prefix, :app)
+      end
+
       def help(parser)
         @out.puts parser
         0

data/lib/daisy_ui/tailwind/sources.rb

@@ -22,6 +22,16 @@ module DaisyUI
 
       attr_reader :components
 
+      # @api private Shared with AppSources.
+      def self.validate_options!(breakpoints, prefix)
+        breakpoints.each do |breakpoint|
+          raise ArgumentError, "invalid breakpoint #{breakpoint.inspect}: give the variant name, e.g. sm or @md" unless BREAKPOINT.match?(breakpoint)
+        end
+        return if prefix.empty? || PREFIX.match?(prefix)
+
+        raise ArgumentError, "invalid prefix #{prefix.inspect}"
+      end
+
       def initialize(manifest, components, responsive: [], prefix: nil)
         @manifest = manifest
         @components = components
@@ -90,14 +100,7 @@ module DaisyUI
 
       def inline(classes) = %(@source inline("#{classes.join(' ')}");)
 
-      def validate!
-        @breakpoints.each do |breakpoint|
-          raise ArgumentError, "invalid breakpoint #{breakpoint.inspect}: give the variant name, e.g. sm or @md" unless BREAKPOINT.match?(breakpoint)
-        end
-        return if @prefix.empty? || PREFIX.match?(@prefix)
-
-        raise ArgumentError, "invalid prefix #{@prefix.inspect}"
-      end
+      def validate! = self.class.validate_options!(@breakpoints, @prefix)
     end
   end
 end

data/lib/daisy_ui/tailwind.rb

@@ -37,11 +37,55 @@ module DaisyUI
       # components. `responsive:` adds breakpoint variants (`%w[sm md]`) of the
       # classes `responsive:` renders; `prefix:` defaults to the
       # DaisyUI.configuration.prefix the components render with.
-      def sources(scan: [], components: [], format: :css, responsive: [], prefix: DaisyUI.configuration.prefix)
+      #
+      # `app: true` gives the app's own components instead (app_components),
+      # or `app: [Widget, …]` the ones named: see AppSources. Their file is
+      # separate from the gem components' and meant to be committed.
+      def sources(scan: [], components: [], app: false, format: :css, responsive: [], prefix: DaisyUI.configuration.prefix)
+        return app_sources(app, scan:, components:).new(app == true ? app_components : app, responsive:, prefix:).render(format) if app
+
         manifest = self.manifest
         used = used_components(scan:, components:, manifest:)
         Sources.new(manifest, used, responsive:, prefix:).render(format)
       end
+
+      # The app's DaisyUI::Base subclasses, sorted by name: every named one
+      # whose constant still names it (a class a code reload replaced is
+      # skipped), defined outside the gem's lib/ or a gem component the app
+      # reopened to declare variants (the gem's own never do). A Rails app is
+      # eager-loaded first.
+      def app_components
+        ::Rails.application.eager_load! if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+        ClassMerge::DaisyGroups.components.select { |component| current?(component) && app_owned?(component) }.sort_by(&:name)
+      end
+
+      # Whether the committed app sources at `path` differ from what the
+      # declarations give now (or the file is missing): a spec can fail on it,
+      # the way the gem's own manifest spec does.
+      def stale?(path, app: true, **)
+        !File.file?(path) || File.read(path) != sources(app:, **)
+      end
+
+      private
+
+      def app_sources(app, scan:, components:)
+        return AppSources if scan.empty? && components.empty?
+
+        raise ArgumentError, "app: gives the app's own components, a file of its own; " \
+                             "scan: and components: give the gem's (#{app.inspect} with #{(scan + components).inspect})"
+      end
+
+      def app_owned?(component)
+        return true unless Object.const_source_location(component.name)&.first.to_s.start_with?(File.join(ROOT, "lib", ""))
+
+        !component.variant_definitions.equal?(Variants::EMPTY)
+      end
+
+      def current?(component)
+        Object.const_get(component.name).equal?(component)
+      rescue NameError
+        false
+      end
     end
   end
 end

data/lib/daisy_ui/unknown_modifier_error.rb

@@ -23,9 +23,16 @@ module DaisyUI
       name = "#{name}##{part}" if part
       message = "#{name} has no modifier #{modifier.inspect}"
       suggestions = DidYouMean::SpellChecker.new(dictionary: known.map(&:to_s)).correct(modifier.to_s)
-      return message if suggestions.empty?
+      message = "#{message}. Did you mean? #{suggestions.map { |s| ":#{s}" }.join(', ')}" unless suggestions.empty?
+      groups.empty? ? message : "#{message}. Variants: #{groups}"
+    end
+
+    # The component's groups and their members, "size: sm, lg; color: …";
+    # a sub-component part has modifiers of its own, so none for it.
+    def groups
+      return "" if part || !component.respond_to?(:modifier_groups)
 
-      "#{message}. Did you mean? #{suggestions.map { |s| ":#{s}" }.join(', ')}"
+      component.modifier_groups.map { |group, members| "#{group}: #{members.join(', ')}" }.join("; ")
     end
   end
 end

data/lib/daisy_ui/updated_at.rb

@@ -3,5 +3,5 @@
 module DaisyUI
   # This timestamp is automatically updated when releasing a new version
   # Format: YYYY-MM-DD HH:MM:SS UTC
-  UPDATED_AT = "2026-10-17 07:27:19 UTC"
+  UPDATED_AT = "2026-10-26 18:45:50 UTC"
 end

data/lib/daisy_ui/variants/match.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # What a `compound` or `on` match means, and the checks that make a typo
+    # fail where it is declared (at boot) rather than never match:
+    #
+    # | value            | matches when                                        |
+    # |------------------|-----------------------------------------------------|
+    # | `:member`        | that member is selected (given, defaulted or set)   |
+    # | `[:a, :b]`       | any of them is; a `nil` in the list means "or none" |
+    # | `nil` / `false`  | no member of that group is                          |
+    # | `true`           | any member of that group is                         |
+    # | `true` / `false` | a flag is on / off                                  |
+    #
+    # @api private
+    class Match
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # `selection` is { group => member or nil }, `on` the flags given.
+      def self.holds?(match, selection, on)
+        match.all? do |key, value|
+          if selection.key?(key)
+            member = selection[key]
+            case value
+            when true then !member.nil?
+            when false, nil then member.nil?
+            when Array then value.include?(member)
+            else member == value
+            end
+          else
+            on.include?(key) == value
+          end
+        end
+      end
+
+      def match!(match)
+        match.each do |key, value|
+          if groups.key?(key)
+            value_members(value).each { |member| member!(key, member) }
+          elsif flags.include?(key)
+            raise ArgumentError, "#{owner}: flag #{key.inspect} matches true or false, got #{value.inspect}" unless BOOLS.include?(value)
+          else
+            raise ArgumentError, "#{owner} has no variant or flag #{key.inspect}"
+          end
+        end
+      end
+
+      def member!(group, member)
+        raise ArgumentError, "#{owner} has no variant #{group.inspect}" unless groups.key?(group)
+        return if groups[group].include?(member)
+
+        raise ArgumentError, "#{owner}: #{group.inspect} has no member #{member.inspect}; #{group}: #{groups[group].join(', ')}"
+      end
+
+      def state!(name)
+        return if @klass.variant_definitions[:states].key?(name)
+
+        raise ArgumentError, "#{owner} has no state #{name.inspect}: declare it with `state #{name.inspect}, \"<variant>\"` first"
+      end
+
+      def slot!(name)
+        return if name == :root || @klass.variant_definitions[:slots].key?(name)
+
+        raise ArgumentError, "#{owner} has no slot #{name.inspect}: declare it with `slot #{name.inspect}` first"
+      end
+
+      private
+
+      BOOLS = [true, false].freeze
+      private_constant :BOOLS
+
+      def value_members(value)
+        return [] if value.nil? || value == true || value == false
+
+        Array(value).compact
+      end
+
+      def groups = @klass.modifier_groups
+
+      # Ungrouped modifiers and registered flags.
+      def flags = Schema.flags(@klass)
+
+      def owner = @klass.name || @klass.inspect
+    end
+  end
+end

data/lib/daisy_ui/variants/rendering.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # The instance side of the Variants API, included in DaisyUI::Base. A
+    # component without declarations (every gem component) skips it all.
+    module Rendering
+      private
+
+      # The `base` classes a `variants` block declared.
+      def variant_base_classes
+        apply_prefix(self.class.variant_definitions[:base])
+      end
+
+      # For `slot` (:root is the component itself): the classes of the
+      # members a default or compound selected (the root's given members are
+      # modifier_classes already), of every compound that holds, and of every
+      # `on` rule that holds, prefixed with its states.
+      def variant_classes(slot = :root)
+        definitions = self.class.variant_definitions
+        return [] if definitions.equal?(EMPTY)
+
+        resolution = variant_resolution
+        [
+          *variant_member_classes(resolution, slot, definitions),
+          *resolution.compounds.map { |compound| apply_prefix(compound[:class][slot]) },
+          *resolution.rules.flat_map { |rule| state_classes(rule, slot, definitions[:states]) }
+        ].compact
+      end
+
+      # Classes for one of the component's parts: the slot's own, those its
+      # variants, compounds and `on` rules give it, then `options[:class]`
+      # (removed from `options`, as component_classes does).
+      def slot_classes(name, options = self.options)
+        slots = self.class.variant_definitions[:slots]
+        raise ArgumentError, "#{self.class.name || self.class.inspect} has no slot #{name.inspect}" unless slots.key?(name)
+
+        merge_classes(apply_prefix(slots[name]), *variant_classes(name), options.delete(:class))
+      end
+
+      # `options` with the slot's classes, to splat into the part.
+      def slot_options(name, options = self.options)
+        classes = slot_classes(name, options)
+        classes ? options.merge(class: classes) : options
+      end
+
+      def variant_resolution
+        @variant_resolution ||= Resolution.new(self.class, modifiers)
+      end
+
+      def variant_member_classes(resolution, slot, definitions)
+        if slot == :root
+          resolution.implied_members.map { |member| apply_prefix(modifier_map[member]) }
+        else
+          resolution.active.map { |member| apply_prefix(definitions[:slot_classes].dig(member, slot)) }
+        end
+      end
+
+      def state_classes(rule, slot, states)
+        return [] unless (classes = rule[:class][slot])
+
+        rule[:states].flat_map do |state|
+          classes.split.map { |token| "#{states.fetch(state)}:#{apply_prefix(token)}" }
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/variants/resolution.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # Which members, compounds and `on` rules hold for one instance, worked
+    # out explicitly rather than left to ClassMerge, so a default or a set
+    # member never renders beside the member the caller gave, with class
+    # merging on or off:
+    #
+    # 1. the caller's members (the last one per group, as ClassMerge keeps)
+    # 2. defaults, for groups the caller left empty
+    # 3. compounds in declaration order; each one's `set` fills or replaces a
+    #    member the caller did not name, and later compounds see it
+    # 4. `on` rules, against the final selection
+    #
+    # @api private
+    class Resolution
+      attr_reader :compounds, :rules
+
+      def initialize(klass, given)
+        definitions = klass.variant_definitions
+        @given = given
+        @selection = klass.modifier_groups.to_h { |group, members| [group, given.reverse.find { |m| members.include?(m) }] }
+        @named = @selection.compact.keys
+        definitions[:defaults].each { |group, member| @selection[group] ||= member }
+        @compounds = matching_compounds(definitions[:compounds])
+        @rules = definitions[:rules].select { |rule| holds?(rule[:match]) }
+      end
+
+      # Members a default or a compound selected, not the caller.
+      def implied_members
+        @selection.filter_map { |group, member| member unless @named.include?(group) }
+      end
+
+      # Every member and flag in effect, for the slots' per-member classes.
+      def active = (@given | implied_members)
+
+      private
+
+      # One at a time: a compound's `set` is seen by the compounds after it.
+      def matching_compounds(compounds)
+        compounds.each_with_object([]) do |compound, matched|
+          next unless holds?(compound[:match])
+
+          matched << compound
+          compound[:set].each { |group, member| @selection[group] = member unless @named.include?(group) }
+        end
+      end
+
+      def holds?(match) = Match.holds?(match, @selection, @given)
+    end
+  end
+end

data/lib/daisy_ui/variants/schema.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  class Variants
+    # `Component.variants.schema`: a component's declarations as plain,
+    # frozen data. A component that only calls `register_modifiers` gets its
+    # variants and flags, with the rest empty.
+    #
+    # @api private
+    class Schema
+      # Ungrouped modifiers and the flags registered without a class.
+      def self.flags(klass)
+        grouped = klass.modifier_groups.values.flatten
+        ((klass.modifiers || {}).keys - grouped) | klass.flags
+      end
+
+      def initialize(klass)
+        @klass = klass
+        @definitions = klass.variant_definitions
+      end
+
+      def to_h
+        Shareable.share(
+          base:,
+          variants: @klass.modifier_groups.transform_values(&:dup),
+          flags: self.class.flags(@klass),
+          defaults: @definitions[:defaults].dup,
+          compounds: @definitions[:compounds].map { |entry| { match: entry[:match], class: shown(entry[:class]), set: entry[:set] } },
+          on: @definitions[:rules].map { |entry| { states: entry[:states], match: entry[:match], class: shown(entry[:class]) } },
+          states: @definitions[:states].dup,
+          slots: { root: base, **@definitions[:slots] }
+        )
+      end
+
+      # Every class token the declarations can render, `prefix` included the
+      # way Base#apply_prefix adds it (after any state), sorted.
+      def literal_classes(prefix)
+        plain = [base, *modifier_classes, *@definitions[:slots].values, *slot_member_classes, *compound_classes]
+        plain = plain.compact.flat_map(&:split).map { |token| "#{prefix}#{token}" }
+        (plain + state_classes(prefix)).uniq.sort
+      end
+
+      private
+
+      def base
+        classes = [@klass.component_class&.to_s, @definitions[:base]].compact.join(" ")
+        classes.empty? ? nil : classes
+      end
+
+      def modifier_classes = (@klass.modifiers || {}).values
+
+      def slot_member_classes = @definitions[:slot_classes].values.flat_map(&:values)
+
+      def compound_classes = @definitions[:compounds].flat_map { |entry| entry[:class].values }
+
+      def state_classes(prefix)
+        @definitions[:rules].flat_map do |rule|
+          tokens = rule[:class].values.flat_map(&:split)
+          rule[:states].flat_map do |state|
+            tokens.map { |token| "#{@definitions[:states].fetch(state)}:#{prefix}#{token}" }
+          end
+        end
+      end
+
+      # A root-only class shows as its String, per-slot classes as the Hash.
+      def shown(classes)
+        return nil if classes.empty?
+
+        classes.keys == [:root] ? classes[:root] : classes
+      end
+    end
+  end
+end

data/lib/daisy_ui/variants.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  # The declarative layer over `register_modifiers`: compound looks, defaults,
+  # browser states and parts (slots), declared once in the class body.
+  #
+  #   class Widget < DaisyUI::Button
+  #     variants do
+  #       base "font-medium"
+  #       variant :size, sm: "btn-sm [--fontsize:var(--text-sm)]"
+  #       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
+  #
+  # `variant` and `flag` write through `register_modifiers` (so ClassMerge
+  # groups, inheritance and finalize! stay as they are); everything else lands
+  # in the class's `variant_definitions`, a frozen Hash replaced on every
+  # write. `Widget.variants.schema` describes it all as plain data. Matching,
+  # validation and rendering live in Variants::Match, Variants::Resolution and
+  # Variants::Rendering.
+  class Variants
+    EMPTY = Shareable.make(
+      { base: nil, defaults: {}, compounds: [], rules: [], states: {}, slots: {}, slot_classes: {} }
+    )
+    STATE_PREFIX = /\A[^\s"'`;{}\\]+\z/
+
+    # The DSL for `klass`, with `block` evaluated against it.
+    def self.build(klass, &block)
+      new(klass).tap { |dsl| dsl.instance_exec(&block) if block }
+    end
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    # Classes every instance gets, after the inherited base.
+    def base(classes)
+      write(base: [definitions[:base], classes].compact.join(" "))
+    end
+
+    # A group of alternatives: `variant :size, sm: "btn-sm", lg: "btn-lg"`. A
+    # Hash value gives classes per slot (`sm: { root: "…", menu: "…" }`).
+    def variant(group, **members)
+      register(group => members.transform_values { |classes| root_classes(classes) })
+      members.each { |member, classes| write_slot_classes(member, classes) }
+      self
+    end
+
+    # An on/off modifier: `flag :wide, "btn-wide"`, or a flag with no class of
+    # its own (`flag :collapsed`) that compounds and `on` rules can match.
+    def flag(name, classes = nil)
+      return tap { @klass.register_flags(name) } if classes.nil?
+
+      register(name => root_classes(classes))
+      write_slot_classes(name, classes)
+      self
+    end
+
+    # The member used when the caller names no member of `group`.
+    def default(group, member)
+      check.member!(group, member)
+      write(defaults: definitions[:defaults].merge(group => member))
+    end
+
+    # Adds `class:` and sets the variants in `set:` (members the caller did
+    # not name) when every key of `match` holds. See Variants::Match.
+    def compound(**match)
+      classes = match.delete(:class)
+      set = match.delete(:set) || {}
+      raise ArgumentError, "#{owner}: compound #{match.inspect} needs class: or set:" if classes.nil? && set.empty?
+
+      check.match!(match)
+      set.each { |group, member| check.member!(group, member) }
+      add(:compounds, match:, class: slot_hash(classes), set:)
+    end
+
+    # Names a Tailwind variant prefix once: `state :open, "[.dropdown[open]>&]"`.
+    def state(name, prefix)
+      raise ArgumentError, "#{owner}: state #{name.inspect} needs a Tailwind variant, got #{prefix.inspect}" unless STATE_PREFIX.match?(prefix.to_s)
+
+      write(states: definitions[:states].merge(name => prefix.to_s))
+    end
+
+    # Like compound, with every class prefixed by each of the `states`.
+    def on(states, **match)
+      states = Array(states)
+      classes = match.delete(:class)
+      raise ArgumentError, "#{owner}: on #{states.inspect} needs class:" if classes.nil?
+
+      states.each { |name| check.state!(name) }
+      check.match!(match)
+      add(:rules, states:, match:, class: slot_hash(classes))
+    end
+
+    # A part of the component (`root` is the component itself), with the
+    # classes it always gets. Read with Base#slot_classes / #slot_options.
+    def slot(name, classes = nil)
+      raise ArgumentError, "#{owner}: :root is the component itself, not a slot to declare" if name == :root
+
+      write(slots: definitions[:slots].merge(name => classes))
+    end
+
+    # Plain, frozen data describing the component, for docs pages, galleries
+    # and design-tool parity checks.
+    def schema
+      Schema.new(@klass).to_h
+    end
+
+    # Every class the component's declarations can render, prefixed as
+    # DaisyUI.configuration.prefix renders them: what Tailwind needs to see.
+    def literal_classes(prefix: nil)
+      Schema.new(@klass).literal_classes(prefix.to_s)
+    end
+
+    private
+
+    def definitions = @klass.variant_definitions
+
+    def owner = @klass.name || @klass.inspect
+
+    def check = Match.new(@klass)
+
+    def write(**changes)
+      @klass.variant_definitions = definitions.merge(changes)
+      self
+    end
+
+    def add(key, **entry)
+      write(key => [*definitions[key], entry])
+    end
+
+    def register(modifiers)
+      @klass.register_modifiers(modifiers)
+    end
+
+    def root_classes(classes)
+      classes.is_a?(Hash) ? slot_hash(classes)[:root].to_s : classes.to_s
+    end
+
+    # Slot parts of a member, kept apart from `modifiers`, which only ever
+    # holds the root's String.
+    def write_slot_classes(member, classes)
+      parts = classes.is_a?(Hash) ? slot_hash(classes).except(:root) : {}
+      slot_classes = definitions[:slot_classes].except(member)
+      write(slot_classes: parts.empty? ? slot_classes : slot_classes.merge(member => parts))
+    end
+
+    # `"a b"` or `{ root: "a", menu: "b" }` as `{ slot => classes }`.
+    def slot_hash(classes)
+      return {} if classes.nil?
+      return { root: classes.to_s } unless classes.is_a?(Hash)
+
+      classes.each_key { |slot| check.slot!(slot) }
+      classes.transform_values(&:to_s)
+    end
+  end
+end

data/lib/daisy_ui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DaisyUI
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/lib/daisy_ui.rb

@@ -14,6 +14,8 @@ loader.ignore("#{__dir__}/daisy_ui/updated_at.rb")
 # The Rails engine references Rails::Engine, so it is required explicitly below
 # (only when Rails is present) rather than autoloaded.
 loader.ignore("#{__dir__}/daisy_ui/engine.rb")
+# lib/tasks holds the engine's rake tasks, no constants.
+loader.ignore("#{__dir__}/tasks")
 loader.setup # ready!
 loader.load_file("#{__dir__}/daisy_ui/base.rb")
 

data/lib/tasks/daisyui.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Loaded by the Rails engine (Rails loads an engine's lib/tasks/*.rake).
+namespace :daisyui do
+  desc "Write the Tailwind sources of the app's own DaisyUI components to OUTPUT (stdout without one)"
+  task :tailwind, [:output] => :environment do |_task, args|
+    argv = ["--app"]
+    argv.push("--output", args[:output]) if args[:output]
+    status = DaisyUI::Tailwind::Command.run(argv)
+    exit(status) unless status.zero?
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daisyui
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -128,6 +128,7 @@ files:
 - lib/daisy_ui/loading.rb
 - lib/daisy_ui/mask.rb
 - lib/daisy_ui/mcp_server.rb
+- lib/daisy_ui/mcp_server/variants_guide.rb
 - lib/daisy_ui/megamenu.rb
 - lib/daisy_ui/menu.rb
 - lib/daisy_ui/menu_item.rb
@@ -161,6 +162,7 @@ files:
 - lib/daisy_ui/table_row.rb
 - lib/daisy_ui/tabs.rb
 - lib/daisy_ui/tailwind.rb
+- lib/daisy_ui/tailwind/app_sources.rb
 - lib/daisy_ui/tailwind/candidate.rb
 - lib/daisy_ui/tailwind/command.rb
 - lib/daisy_ui/tailwind/lexer.rb
@@ -179,8 +181,14 @@ files:
 - lib/daisy_ui/unknown_modifier_error.rb
 - lib/daisy_ui/updated_at.rb
 - lib/daisy_ui/validator.rb
+- lib/daisy_ui/variants.rb
+- lib/daisy_ui/variants/match.rb
+- lib/daisy_ui/variants/rendering.rb
+- lib/daisy_ui/variants/resolution.rb
+- lib/daisy_ui/variants/schema.rb
 - lib/daisy_ui/version.rb
 - lib/daisyui.rb
+- lib/tasks/daisyui.rake
 homepage: https://github.com/mhenrixon/daisyui
 licenses:
 - MIT