daisyui 2.1.0 → 2.2.0

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.0"
+  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.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -55,6 +55,7 @@ description: DaisyUI is a comprehensive Ruby UI component library that brings Da
 email: mikael@zoolutions.llc
 executables:
 - daisyui-mcp
+- daisyui-tailwind
 extensions: []
 extra_rdoc_files: []
 files:
@@ -69,7 +70,9 @@ files:
 - app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js
 - app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js.map
 - config/importmap.rb
+- data/daisyui/tailwind_manifest.json
 - exe/daisyui-mcp
+- exe/daisyui-tailwind
 - lib/daisy_ui.rb
 - lib/daisy_ui/accordion.rb
 - lib/daisy_ui/alert.rb
@@ -125,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
@@ -157,6 +161,16 @@ files:
 - lib/daisy_ui/table.rb
 - 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
+- lib/daisy_ui/tailwind/manifest.rb
+- lib/daisy_ui/tailwind/manifest_builder.rb
+- lib/daisy_ui/tailwind/sources.rb
+- lib/daisy_ui/tailwind/unknown_component_error.rb
+- lib/daisy_ui/tailwind/usage.rb
 - lib/daisy_ui/text_rotate.rb
 - lib/daisy_ui/textarea.rb
 - lib/daisy_ui/theme_controller.rb
@@ -167,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