daisyui 2.1.1 → 2.2.1

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-27 04:51:27 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.1"
 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