daisyui 2.0.1 → 2.1.0

data/lib/daisy_ui/class_merge.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "monitor"
-
 module DaisyUI
   # Merges CSS class lists so that later classes win over earlier conflicting
   # ones, for Tailwind utilities and daisyUI modifiers alike:
@@ -16,10 +14,10 @@ module DaisyUI
   module ClassMerge
     TAILWIND_MERGE_VERSION = "1.5.6"
 
-    # Reentrant, so a reset! triggered while the merger is being built (e.g. a
-    # component file configuring DaisyUI as it loads) cannot deadlock.
-    @monitor = Monitor.new
-
+    # The merger (with its LRU) and the Tailwind class groups live in
+    # DaisyUI::Store: one per Ractor, built on first use under the store's
+    # reentrant lock, so a reset! triggered while the merger is being built
+    # (e.g. a component file configuring DaisyUI as it loads) cannot deadlock.
     class << self
       # Accepts strings, nested arrays, nil and false (dropped, as Phlex does
       # for `class:`). Returns a frozen String, "" when empty.
@@ -27,20 +25,33 @@ module DaisyUI
         merger.merge(parts.flatten.select(&:itself).join(" "))
       end
 
+      # Each Ractor's merger remembers the configuration it was built from
+      # and is rebuilt once DaisyUI.configure publishes another, also in a
+      # Ractor where reset! never ran.
       def merger
-        @merger || @monitor.synchronize do
-          @merger ||= Merger.new(config: DaisyUI.configuration.class_merge.merger_config)
-        end
+        configuration = DaisyUI.configuration
+        built_for, merger = Store.fetch(:daisy_ui_class_merger) { build_merger(configuration) }
+        return merger if built_for.equal?(configuration)
+
+        Store.delete(:daisy_ui_class_merger)
+        Store.fetch(:daisy_ui_class_merger) { build_merger(configuration) }.last
       end
 
       # @api private The stock Tailwind class groups, for classifying tokens.
       def tailwind_utils
-        @tailwind_utils ||= ClassGroupUtils.new(TailwindConfig::DEFAULTS)
+        Store.fetch(:daisy_ui_tailwind_utils) { ClassGroupUtils.new(TailwindConfig::DEFAULTS) }
       end
 
-      # Drops the memoized merger so the next merge picks up configuration changes.
+      # Drops the current Ractor's merger so its next merge picks up
+      # configuration changes.
       def reset!
-        @monitor.synchronize { @merger = nil }
+        Store.delete(:daisy_ui_class_merger)
+      end
+
+      private
+
+      def build_merger(configuration)
+        [configuration, Merger.new(config: configuration.class_merge.merger_config(configuration))]
       end
     end
   end

data/lib/daisy_ui/collapsible_sub_menu.rb

@@ -4,6 +4,7 @@ module DaisyUI
   # @private
   class CollapsibleSubMenu < Base
     self.component_class = nil
+    register_flags :collapsible, :open
 
     def initialize(*, **)
       super

data/lib/daisy_ui/configurable/report_log.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Configurable
+    # @api private The unknown modifiers already reported, so :warn and a
+    # callable fire once per key. Remembers up to `limit` keys, then starts
+    # over, so modifiers built from user input cannot grow it without bound.
+    # One per Ractor (DaisyUI::Store), so its Mutex is never shared.
+    class ReportLog
+      def initialize(limit)
+        @limit = limit
+        @keys = Set.new
+        @lock = Mutex.new
+      end
+
+      # True the first time a key is seen.
+      def first?(key)
+        @lock.synchronize do
+          return false if @keys.include?(key)
+
+          @keys.clear if @keys.size >= @limit
+          @keys.add(key)
+          true
+        end
+      end
+
+      def clear
+        @lock.synchronize { @keys.clear }
+      end
+
+      def size
+        @lock.synchronize { @keys.size }
+      end
+    end
+  end
+end

data/lib/daisy_ui/configurable.rb

@@ -2,15 +2,45 @@
 
 module DaisyUI
   module Configurable
+    # Created when DaisyUI extends this module, at load, so `configuration` is
+    # a plain read with no check-then-set race.
+    def self.extended(base)
+      base.instance_variable_set(:@configuration, Configuration.new)
+    end
+
+    # Yields a writable copy of the configuration, then finalizes the copy
+    # (see finalize!) and publishes it. Calling configure again keeps
+    # working, no reader (another thread, a non-main Ractor) meets a
+    # half-changed or writable configuration, and a block that raises
+    # publishes nothing. Calls are serialized, so each starts from what the
+    # previous one published.
     def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-      ClassMerge.reset!
-      configuration
+      configure_lock.synchronize do
+        draft = configuration.dup
+        yield(draft) if block_given?
+        @configuration = draft.finalize!
+        ClassMerge.reset!
+        finalize!
+        configuration
+      end
     end
 
     def configuration
-      @configuration ||= Configuration.new
+      @configuration
+    end
+
+    # Freezes what a non-main Ractor reads (this configuration and every
+    # component's registries) so DaisyUI::ClassMerge.merge runs in any Ractor.
+    # configure calls it, and the Rails engine calls it once the app has
+    # booted; an app with neither calls it at the end of boot. Afterwards
+    # change settings only through configure: writing to the frozen
+    # configuration raises. A configured value that cannot be made shareable
+    # is kept as it is (see Shareable.share), never raised on.
+    def finalize!
+      ClassMerge::DaisyGroups.components.each(&:finalize!)
+      configuration.finalize!
+      ClassMerge.tailwind_utils
+      self
     end
 
     class Modifiers
@@ -19,6 +49,19 @@ module DaisyUI
         @groups = {}
       end
 
+      def initialize_copy(source)
+        super
+        @modifiers = @modifiers.transform_values(&:dup)
+        @groups = @groups.dup
+      end
+
+      # @api private Called by DaisyUI.finalize!.
+      def finalize!
+        Shareable.share(@modifiers)
+        Shareable.share(@groups)
+        freeze
+      end
+
       # `group:` makes the modifier an alternative to the component's other
       # modifiers in that group, e.g. `add(:huge, classes: "btn-xl",
       # component: DaisyUI::Button, group: :size)`.
@@ -52,12 +95,67 @@ module DaisyUI
     end
 
     class Configuration
+      UNKNOWN_MODIFIER_MODES = %i[raise warn ignore].freeze
+      REPORTED_UNKNOWN_MODIFIERS_LIMIT = 1_000
+
       attr_reader :prefix
 
       def initialize
         @prefix = nil
       end
 
+      def initialize_copy(source)
+        super
+        @class_merge = @class_merge&.dup
+        @modifiers = @modifiers&.dup
+      end
+
+      # @api private Called by DaisyUI.configure and DaisyUI.finalize!. A
+      # callable unknown_modifiers that cannot be made shareable (a lambda
+      # that closes over app state, an object holding a logger) is kept: the
+      # configuration is then frozen but readable on the main Ractor only.
+      def finalize!
+        class_merge.finalize!
+        modifiers.finalize!
+        Shareable.share(@prefix)
+        Shareable.share(@unknown_modifiers)
+        freeze
+      end
+
+      # What a component does with a positional modifier it does not know:
+      # :raise, :warn (once per component and modifier), :ignore, or a callable
+      # that receives the DaisyUI::UnknownModifierError (once per component and
+      # modifier), e.g. `->(error) { Appsignal.report_error(error) }`.
+      #
+      # Defaults to :raise under Rails in development and test, :warn otherwise.
+      def unknown_modifiers
+        @unknown_modifiers || default_unknown_modifiers
+      end
+
+      def unknown_modifiers=(mode)
+        valid = mode.nil? || mode.respond_to?(:call) || UNKNOWN_MODIFIER_MODES.include?(mode)
+        raise ArgumentError, "unknown_modifiers must be :raise, :warn, :ignore or a callable, got #{mode.inspect}" unless valid
+
+        @unknown_modifiers = mode
+      end
+
+      # @api private Builds the error only when it will be raised or reported.
+      def report_unknown_modifier(component:, modifier:, known:, part: nil)
+        mode = unknown_modifiers
+        return if mode == :ignore
+
+        error = -> { UnknownModifierError.new(component:, modifier:, known:, part:) }
+        raise error.call if mode == :raise
+        return unless first_report?([component, part, modifier])
+
+        mode == :warn ? warn("[DaisyUI] #{error.call.message}") : mode.call(error.call)
+      end
+
+      # @api private
+      def reset_reported_unknown_modifiers!
+        reported_unknown_modifiers.clear
+      end
+
       def prefix=(prefix)
         @prefix = prefix
         ClassMerge.reset!
@@ -70,6 +168,32 @@ module DaisyUI
       def modifiers
         @modifiers ||= Modifiers.new
       end
+
+      private
+
+      def first_report?(key)
+        reported_unknown_modifiers.first?(key)
+      end
+
+      # What was already reported lives per Ractor, outside the configuration,
+      # which stays shareable.
+      def reported_unknown_modifiers
+        Store.fetch(:daisy_ui_reported_unknown_modifiers) { ReportLog.new(REPORTED_UNKNOWN_MODIFIERS_LIMIT) }
+      end
+
+      def default_unknown_modifiers
+        return :warn unless defined?(::Rails) && ::Rails.respond_to?(:env)
+
+        %w[development test].include?(::Rails.env.to_s) ? :raise : :warn
+      end
+    end
+
+    private
+
+    # Reentrant, and one per Ractor (DaisyUI::Store) so it is never shared;
+    # configure writes DaisyUI's ivar, so only the main Ractor gets that far.
+    def configure_lock
+      Store.fetch(:daisy_ui_configure_lock) { Monitor.new }
     end
   end
 end

data/lib/daisy_ui/dropdown.rb

@@ -5,6 +5,7 @@ require "securerandom"
 module DaisyUI
   class Dropdown < Base
     self.component_class = :dropdown
+    register_flags :popover, :tap_to_close
 
     # Placement modifiers that, in :popover mode, must live on the popover
     # element itself (DaisyUI's `position-area` rule is on `.dropdown`).

data/lib/daisy_ui/engine.rb

@@ -4,26 +4,43 @@ module DaisyUI
   # Optional Rails integration. Loaded only when Rails::Engine is defined (see
   # lib/daisy_ui.rb), so the gem stays a plain Phlex library outside Rails.
   #
-  # It exposes the gem's bundled JavaScript (the opt-in `daisy-dropdown`
-  # Stimulus controller) to the host app:
-  #   * appends the JS dir to importmap-rails' paths and auto-pins it, so
-  #     consumers get `daisy_ui/controllers/daisy_dropdown_controller` with no
-  #     manual pin;
+  # It exposes the gem's bundled Stimulus controllers (`daisy-dropdown`,
+  # `daisy-tooltip`) to the host app:
+  #   * adds config/importmap.rb to importmap-rails' paths, which pins each
+  #     `daisy_ui/controllers/<name>` to its minified build (no manual pin);
   #   * appends the JS dir to the asset load path so Propshaft/Sprockets serve
-  #     the file.
+  #     the .min.js and its sourcemap (Sprockets also needs them precompiled).
   #
-  # The controller is opt-in at the markup level (`Dropdown(:popover, stimulus:
-  # true)`), so apps that never opt in ship no extra behavior.
+  # 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.
   # Asset-only engine: no isolate_namespace, since it exposes no routes, models,
   # or helpers — only static JavaScript — and namespacing would risk surprises in
   # the host app for no benefit.
   class Engine < ::Rails::Engine
     JAVASCRIPT_PATH = root.join("app/javascript")
+    # The minified controllers config/importmap.rb pins, and their sourcemaps.
+    MINIFIED_ASSETS = Dir[JAVASCRIPT_PATH.join("daisy_ui/controllers/*.min.js{,.map}").to_s]
+      .map { |path| Pathname.new(path).relative_path_from(JAVASCRIPT_PATH).to_s }.sort.freeze
 
     initializer "daisy_ui.assets" do |app|
-      app.config.assets.paths << JAVASCRIPT_PATH.to_s if app.config.respond_to?(:assets)
+      next unless app.config.respond_to?(:assets)
+
+      app.config.assets.paths << JAVASCRIPT_PATH.to_s
+      # Sprockets compiles only what is listed; Propshaft compiles every file in
+      # paths. The list is nil unless Sprockets or another engine created it,
+      # and OrderedOptions answers respond_to? for any name, so check the value.
+      precompile = app.config.assets.precompile
+      precompile.concat(MINIFIED_ASSETS) if precompile.is_a?(Array)
     end
 
+    # Once the app has booted, freeze the configuration and component
+    # registries so a non-main Ractor can merge classes. DaisyUI.configure in
+    # an initializer already finalized; this also covers an app that never
+    # calls it and the components loaded during boot (eager loading).
+    # DaisyUI.configure keeps working afterwards, on a copy.
+    config.after_initialize { DaisyUI.finalize! }
+
     initializer "daisy_ui.importmap", before: "importmap" do |app|
       next unless app.config.respond_to?(:importmap)
 

data/lib/daisy_ui/indicator.rb

@@ -19,6 +19,7 @@ module DaisyUI
     private
 
     def build_item_classes(item_modifiers, options)
+      report_unknown_modifiers(item_modifiers, modifier_map.keys, part: :item)
       # Start with base class
       base = apply_prefix("indicator-item")
       # Add modifier classes from position modifiers

data/lib/daisy_ui/mcp_server.rb

@@ -39,6 +39,7 @@ module DaisyUI
         }
       }
     ].freeze
+    Shareable.make(TOOLS) # the Hashes inside too
 
     EXCLUDED_CONSTANTS = %i[Base Configurable Configuration Modifiers VERSION UPDATED_AT McpServer].freeze
 

data/lib/daisy_ui/modal.rb

@@ -3,6 +3,7 @@
 module DaisyUI
   class Modal < Base
     self.component_class = :modal
+    register_flags :tap_outside_to_close
 
     def initialize(*, id:, **)
       super

data/lib/daisy_ui/shareable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  # @api private Deep-freezes a value so a non-main Ractor can read it from a
+  # constant or a class ivar: `Ractor.make_shareable`, or, on engines without
+  # Ractor (JRuby, TruffleRuby), a walk freezing Hash values and Array elements.
+  module Shareable
+    class << self
+      # For the gem's own literals, which must all be shareable: raises if one
+      # is not.
+      def make(value)
+        ractor? ? ::Ractor.make_shareable(value) : deep_freeze(value)
+      end
+
+      # For what an app configures. Freezes Hashes, Arrays and Strings all the
+      # way down, makes a capture-free Proc shareable, and keeps anything else
+      # (a Proc that closes over app state, a logger) as it is, so whatever
+      # holds it is readable on the main Ractor only. Never raises, and never
+      # hands an object it does not know to Ractor.make_shareable, which
+      # freezes as it goes and would leave a logger frozen before failing.
+      def share(value)
+        case value
+        when Hash
+          value.each do |key, member|
+            share(key)
+            share(member)
+          end.freeze
+        when Array then value.each { |member| share(member) }.freeze
+        when String then value.freeze
+        when Proc then share_proc(value)
+        else value
+        end
+      end
+
+      def ractor?
+        defined?(::Ractor) ? ::Ractor.respond_to?(:make_shareable) : false
+      end
+
+      private
+
+      def share_proc(callable)
+        ractor? ? ::Ractor.make_shareable(callable) : callable
+      rescue ::Ractor::Error, ArgumentError
+        callable
+      end
+
+      def deep_freeze(value)
+        case value
+        when Hash then value.each_value { |member| deep_freeze(member) }
+        when Array then value.each { |member| deep_freeze(member) }
+        end
+        value.freeze
+      end
+    end
+  end
+end

data/lib/daisy_ui/steps.rb

@@ -27,6 +27,7 @@ module DaisyUI
     private
 
     def build_step_classes(step_modifiers, options)
+      report_unknown_modifiers(step_modifiers, step_modifier_map.keys, part: :step)
       base = apply_prefix("step")
       mod_classes = step_modifiers.filter_map { |m| apply_prefix(step_modifier_map[m]) }
       custom = options.delete(:class)

data/lib/daisy_ui/store.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module DaisyUI
+  # @api private Per-Ractor lazy storage for caches that must not live in a
+  # class ivar or a constant (the class-merge merger, the Tailwind class
+  # groups, the unknown-modifier report log):
+  #
+  #   DaisyUI::Store.fetch(:daisy_ui_merger) { Merger.new(...) }
+  #   DaisyUI::Store.delete(:daisy_ui_merger)
+  #
+  # Adapted from conformance-kit's ConformanceKit::Store (MIT, same author),
+  # which daisyui cannot depend on at runtime, plus `delete`. Every Ractor has
+  # its own Monitor-guarded table: reentrant, so an initializer may fetch or
+  # delete other keys. On Ruby 3.4+ the table comes from
+  # `Ractor.store_if_absent`. Below 3.4 the main Ractor's table is created at
+  # load (never lazily, so there is no check-then-set race), and a non-main
+  # Ractor keeps its own in Ractor-local storage.
+  module Store
+    # One Ractor's values. Reads skip the lock once a key is stored.
+    class Table
+      def initialize
+        @monitor = Monitor.new
+        @values = {}
+      end
+
+      def fetch(key)
+        @values.fetch(key) do
+          @monitor.synchronize { @values.fetch(key) { @values[key] = yield } }
+        end
+      end
+
+      def delete(key)
+        @monitor.synchronize { @values.delete(key) }
+      end
+    end
+
+    class << self
+      def fetch(key, &init)
+        raise ArgumentError, "DaisyUI::Store.fetch(#{key.inspect}) needs an initializer block" unless init
+
+        table.fetch(key, &init)
+      end
+
+      def delete(key)
+        table.delete(key)
+      end
+
+      def main_ractor?
+        !defined?(::Ractor) || ::Ractor.current == ::Ractor.main
+      end
+
+      def native?
+        defined?(::Ractor) ? ::Ractor.respond_to?(:store_if_absent) : false
+      end
+
+      private
+
+      def table
+        return ::Ractor.store_if_absent(:daisy_ui_store) { Table.new } if native?
+        return ::Ractor.current[:daisy_ui_store] ||= Table.new unless main_ractor?
+
+        # Set once below, at load, below Ruby 3.4; only the main Ractor reads it.
+        @main_table # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+    end
+
+    @main_table = Table.new unless native?
+  end
+end

data/lib/daisy_ui/sub_menu.rb

@@ -3,6 +3,8 @@
 module DaisyUI
   # @private
   class SubMenu < Base
+    register_flags :open
+
     def initialize(*, **)
       super
       @items = []

data/lib/daisy_ui/tab.rb

@@ -36,5 +36,11 @@ module DaisyUI
         div role: :tabpanel, class: content_classes, **options, &block
       end
     end
+
+    private
+
+    # Tab only dispatches: TabWithContent or TabWithoutContent validates the
+    # modifiers when it is built.
+    def validate_modifiers; end
   end
 end

data/lib/daisy_ui/tab_with_content.rb

@@ -4,6 +4,7 @@ module DaisyUI
   # @private
   class TabWithContent < Base
     self.component_class = :tab
+    register_flags :open, :closed
 
     def initialize(*, content:, label: nil, id: nil, **)
       super(*, **)

data/lib/daisy_ui/tab_without_content.rb

@@ -4,6 +4,7 @@ module DaisyUI
   # @private
   class TabWithoutContent < Base
     self.component_class = :tab
+    register_flags :open, :closed
 
     def initialize(*, label: nil, **)
       super(*, **)

data/lib/daisy_ui/tooltip.rb

@@ -5,6 +5,7 @@ require "securerandom"
 module DaisyUI
   class Tooltip < Base
     self.component_class = :tooltip
+    register_flags :popover
 
     PLACEMENTS = %i[top bottom left right].freeze
     DEFAULT_STIMULUS_IDENTIFIER = "daisy-tooltip"

data/lib/daisy_ui/unknown_modifier_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module DaisyUI
+  # Raised (or warned, or reported) when a component is given a positional
+  # modifier it does not know. See `DaisyUI.configuration.unknown_modifiers`.
+  class UnknownModifierError < ArgumentError
+    attr_reader :component, :modifier, :part
+
+    # `part` names the sub-component method (e.g. :bubble for Chat#bubble).
+    def initialize(component:, modifier:, known:, part: nil)
+      @component = component
+      @modifier = modifier
+      @part = part
+      super(build_message(known))
+    end
+
+    private
+
+    def build_message(known)
+      name = component.name || component.inspect
+      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}. Did you mean? #{suggestions.map { |s| ":#{s}" }.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-09 17:02:17 UTC"
+  UPDATED_AT = "2026-10-15 20:45:37 UTC"
 end

data/lib/daisy_ui/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daisyui
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -63,7 +63,11 @@ files:
 - LICENSE.txt
 - README.md
 - app/javascript/daisy_ui/controllers/daisy_dropdown_controller.js
+- app/javascript/daisy_ui/controllers/daisy_dropdown_controller.min.js
+- app/javascript/daisy_ui/controllers/daisy_dropdown_controller.min.js.map
 - app/javascript/daisy_ui/controllers/daisy_tooltip_controller.js
+- app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js
+- app/javascript/daisy_ui/controllers/daisy_tooltip_controller.min.js.map
 - config/importmap.rb
 - exe/daisyui-mcp
 - lib/daisy_ui.rb
@@ -94,6 +98,7 @@ files:
 - lib/daisy_ui/collapse.rb
 - lib/daisy_ui/collapsible_sub_menu.rb
 - lib/daisy_ui/configurable.rb
+- lib/daisy_ui/configurable/report_log.rb
 - lib/daisy_ui/countdown.rb
 - lib/daisy_ui/diff.rb
 - lib/daisy_ui/divider.rb
@@ -137,11 +142,13 @@ files:
 - lib/daisy_ui/range.rb
 - lib/daisy_ui/rating.rb
 - lib/daisy_ui/select.rb
+- lib/daisy_ui/shareable.rb
 - lib/daisy_ui/skeleton.rb
 - lib/daisy_ui/stack.rb
 - lib/daisy_ui/stat.rb
 - lib/daisy_ui/status.rb
 - lib/daisy_ui/steps.rb
+- lib/daisy_ui/store.rb
 - lib/daisy_ui/sub_menu.rb
 - lib/daisy_ui/swap.rb
 - lib/daisy_ui/tab.rb
@@ -157,6 +164,7 @@ files:
 - lib/daisy_ui/toast.rb
 - lib/daisy_ui/toggle.rb
 - lib/daisy_ui/tooltip.rb
+- lib/daisy_ui/unknown_modifier_error.rb
 - lib/daisy_ui/updated_at.rb
 - lib/daisy_ui/validator.rb
 - lib/daisy_ui/version.rb