daisyui 1.3.1 → 2.0.0

data/lib/daisy_ui/checkbox.rb

@@ -30,99 +30,101 @@ module DaisyUI
     end
 
     register_modifiers(
-      # Colors
-      # "sm:checkbox-neutral"
-      # "@sm:checkbox-neutral"
-      # "md:checkbox-neutral"
-      # "@md:checkbox-neutral"
-      # "lg:checkbox-neutral"
-      # "@lg:checkbox-neutral"
-      neutral: "checkbox-neutral",
-      # "sm:checkbox-primary"
-      # "@sm:checkbox-primary"
-      # "md:checkbox-primary"
-      # "@md:checkbox-primary"
-      # "lg:checkbox-primary"
-      # "@lg:checkbox-primary"
-      primary: "checkbox-primary",
-      # "sm:checkbox-secondary"
-      # "@sm:checkbox-secondary"
-      # "md:checkbox-secondary"
-      # "@md:checkbox-secondary"
-      # "lg:checkbox-secondary"
-      # "@lg:checkbox-secondary"
-      secondary: "checkbox-secondary",
-      # "sm:checkbox-accent"
-      # "@sm:checkbox-accent"
-      # "md:checkbox-accent"
-      # "@md:checkbox-accent"
-      # "lg:checkbox-accent"
-      # "@lg:checkbox-accent"
-      accent: "checkbox-accent",
-      # "sm:checkbox-success"
-      # "@sm:checkbox-success"
-      # "md:checkbox-success"
-      # "@md:checkbox-success"
-      # "lg:checkbox-success"
-      # "@lg:checkbox-success"
-      success: "checkbox-success",
-      # "sm:checkbox-warning"
-      # "@sm:checkbox-warning"
-      # "md:checkbox-warning"
-      # "@md:checkbox-warning"
-      # "lg:checkbox-warning"
-      # "@lg:checkbox-warning"
-      warning: "checkbox-warning",
-      # "sm:checkbox-info"
-      # "@sm:checkbox-info"
-      # "md:checkbox-info"
-      # "@md:checkbox-info"
-      # "lg:checkbox-info"
-      # "@lg:checkbox-info"
-      info: "checkbox-info",
-      # "sm:checkbox-error"
-      # "@sm:checkbox-error"
-      # "md:checkbox-error"
-      # "@md:checkbox-error"
-      # "lg:checkbox-error"
-      # "@lg:checkbox-error"
-      error: "checkbox-error",
-      # Sizes
-      # "sm:checkbox-xs"
-      # "@sm:checkbox-xs"
-      # "md:checkbox-xs"
-      # "@md:checkbox-xs"
-      # "lg:checkbox-xs"
-      # "@lg:checkbox-xs"
-      xs: "checkbox-xs",
-      # "sm:checkbox-sm"
-      # "@sm:checkbox-sm"
-      # "md:checkbox-sm"
-      # "@md:checkbox-sm"
-      # "lg:checkbox-sm"
-      # "@lg:checkbox-sm"
-      sm: "checkbox-sm",
-      # "sm:checkbox-md"
-      # "@sm:checkbox-md"
-      # "md:checkbox-md"
-      # "@md:checkbox-md"
-      # "lg:checkbox-md"
-      # "@lg:checkbox-md"
-      md: "checkbox-md",
-      # "sm:checkbox-lg"
-      # "@sm:checkbox-lg"
-      # "md:checkbox-lg"
-      # "@md:checkbox-lg"
-      # "lg:checkbox-lg"
-      # "@lg:checkbox-lg"
-      lg: "checkbox-lg",
-      # "sm:checkbox-xl"
-      # "@sm:checkbox-xl"
-      # "md:checkbox-xl"
-      # "@md:checkbox-xl"
-      # "lg:checkbox-xl"
-      # "@lg:checkbox-xl"
-      xl: "checkbox-xl"
+      color: {
+        # "sm:checkbox-neutral"
+        # "@sm:checkbox-neutral"
+        # "md:checkbox-neutral"
+        # "@md:checkbox-neutral"
+        # "lg:checkbox-neutral"
+        # "@lg:checkbox-neutral"
+        neutral: "checkbox-neutral",
+        # "sm:checkbox-primary"
+        # "@sm:checkbox-primary"
+        # "md:checkbox-primary"
+        # "@md:checkbox-primary"
+        # "lg:checkbox-primary"
+        # "@lg:checkbox-primary"
+        primary: "checkbox-primary",
+        # "sm:checkbox-secondary"
+        # "@sm:checkbox-secondary"
+        # "md:checkbox-secondary"
+        # "@md:checkbox-secondary"
+        # "lg:checkbox-secondary"
+        # "@lg:checkbox-secondary"
+        secondary: "checkbox-secondary",
+        # "sm:checkbox-accent"
+        # "@sm:checkbox-accent"
+        # "md:checkbox-accent"
+        # "@md:checkbox-accent"
+        # "lg:checkbox-accent"
+        # "@lg:checkbox-accent"
+        accent: "checkbox-accent",
+        # "sm:checkbox-success"
+        # "@sm:checkbox-success"
+        # "md:checkbox-success"
+        # "@md:checkbox-success"
+        # "lg:checkbox-success"
+        # "@lg:checkbox-success"
+        success: "checkbox-success",
+        # "sm:checkbox-warning"
+        # "@sm:checkbox-warning"
+        # "md:checkbox-warning"
+        # "@md:checkbox-warning"
+        # "lg:checkbox-warning"
+        # "@lg:checkbox-warning"
+        warning: "checkbox-warning",
+        # "sm:checkbox-info"
+        # "@sm:checkbox-info"
+        # "md:checkbox-info"
+        # "@md:checkbox-info"
+        # "lg:checkbox-info"
+        # "@lg:checkbox-info"
+        info: "checkbox-info",
+        # "sm:checkbox-error"
+        # "@sm:checkbox-error"
+        # "md:checkbox-error"
+        # "@md:checkbox-error"
+        # "lg:checkbox-error"
+        # "@lg:checkbox-error"
+        error: "checkbox-error"
+      },
+      size: {
+        # "sm:checkbox-xs"
+        # "@sm:checkbox-xs"
+        # "md:checkbox-xs"
+        # "@md:checkbox-xs"
+        # "lg:checkbox-xs"
+        # "@lg:checkbox-xs"
+        xs: "checkbox-xs",
+        # "sm:checkbox-sm"
+        # "@sm:checkbox-sm"
+        # "md:checkbox-sm"
+        # "@md:checkbox-sm"
+        # "lg:checkbox-sm"
+        # "@lg:checkbox-sm"
+        sm: "checkbox-sm",
+        # "sm:checkbox-md"
+        # "@sm:checkbox-md"
+        # "md:checkbox-md"
+        # "@md:checkbox-md"
+        # "lg:checkbox-md"
+        # "@lg:checkbox-md"
+        md: "checkbox-md",
+        # "sm:checkbox-lg"
+        # "@sm:checkbox-lg"
+        # "md:checkbox-lg"
+        # "@md:checkbox-lg"
+        # "lg:checkbox-lg"
+        # "@lg:checkbox-lg"
+        lg: "checkbox-lg",
+        # "sm:checkbox-xl"
+        # "@sm:checkbox-xl"
+        # "md:checkbox-xl"
+        # "@md:checkbox-xl"
+        # "lg:checkbox-xl"
+        # "@lg:checkbox-xl"
+        xl: "checkbox-xl"
+      }
     )
   end
 end

data/lib/daisy_ui/class_merge/cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module DaisyUI
+  module ClassMerge
+    # Thread-safe LRU cache. Ruby hashes keep insertion order, so re-inserting
+    # a key on every hit moves it to the end and the first key is always the
+    # least recently used one.
+    class Cache
+      def initialize(max_size)
+        @max_size = max_size
+        @data = {}
+        @monitor = Monitor.new
+      end
+
+      # Returns the cached value for key, or stores and returns the block's
+      # result. A nil result is not stored.
+      def getset(key)
+        @monitor.synchronize do
+          if @data.key?(key)
+            value = @data.delete(key)
+            @data[key] = value
+            return value
+          end
+
+          value = yield
+          return value if value.nil?
+
+          @data.shift if @data.size >= @max_size
+          @data[key] = value
+        end
+      end
+
+      def size
+        @monitor.synchronize { @data.size }
+      end
+    end
+  end
+end

data/lib/daisy_ui/class_merge/class_group_utils.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# Ported from tailwind_merge 1.5.6 (https://github.com/gjtorikian/tailwind_merge)
+# Copyright (c) 2022 Garen J. Torikian. MIT License, see LICENSE-tailwind_merge.txt.
+
+module DaisyUI
+  module ClassMerge
+    class ClassGroupUtils
+      attr_reader :class_map
+
+      CLASS_PART_SEPARATOR = "-"
+
+      ARBITRARY_PROPERTY_REGEX = /^\[(.+)\]$/
+
+      def initialize(config)
+        @config = config
+        @class_map = create_class_map(config)
+      end
+
+      def class_group_id(class_name)
+        class_parts = class_name.split(CLASS_PART_SEPARATOR)
+
+        # Classes like `-inset-1` produce an empty string as first class_part.
+        # Assume that classes for negative values are used correctly and remove it from class_parts.
+        class_parts.shift if class_parts.first == "" && class_parts.length != 1
+
+        get_group_recursive(class_parts, @class_map) || get_group_id_for_arbitrary_property(class_name)
+      end
+
+      def get_group_recursive(class_parts, class_part_object, index = 0)
+        return class_part_object[:class_group_id] if index == class_parts.length
+
+        current_class_part = class_parts[index]
+
+        next_class_part_object = class_part_object[:next_part][current_class_part]
+
+        if next_class_part_object
+          class_group_from_next_class_part = get_group_recursive(class_parts, next_class_part_object, index + 1)
+          return class_group_from_next_class_part if class_group_from_next_class_part
+        end
+
+        return if class_part_object[:validators].empty?
+
+        class_rest = index.zero? ? class_parts.join(CLASS_PART_SEPARATOR) : class_parts[index..].join(CLASS_PART_SEPARATOR)
+
+        # Theme procs are expanded at trie-build time (see process_classes_recursively),
+        # so validators here are always plain value validators.
+        result = class_part_object[:validators].find do |v|
+          v[:validator].call(class_rest)
+        end
+
+        result&.fetch(:class_group_id, nil)
+      end
+
+      def get_conflicting_class_group_ids(class_group_id, has_postfix_modifier)
+        conflicts = @config[:conflicting_class_groups][class_group_id] || []
+
+        return [*conflicts, *@config[:conflicting_class_group_modifiers][class_group_id]] if has_postfix_modifier && @config[:conflicting_class_group_modifiers][class_group_id]
+
+        conflicts
+      end
+
+      private
+
+      def create_class_map(config)
+        theme = config[:theme]
+        class_groups = config[:class_groups]
+        class_map = {
+          next_part: {},
+          validators: []
+        }
+
+        class_groups.each do |(class_group_id, class_group)|
+          process_classes_recursively(class_group, class_map, class_group_id, theme)
+        end
+
+        class_map
+      end
+
+      def process_classes_recursively(class_group, class_part_object, class_group_id, theme)
+        class_group.each do |class_definition|
+          if class_definition.is_a?(String)
+            class_part_object_to_edit = class_definition.empty? ? class_part_object : get_class_part(class_part_object, class_definition)
+            class_part_object_to_edit[:class_group_id] = class_group_id
+          elsif class_definition.is_a?(Proc)
+            if from_theme?(class_definition)
+              process_classes_recursively(class_definition.call(@config), class_part_object, class_group_id, theme)
+            else
+              class_part_object[:validators] << {
+                validator: class_definition,
+                class_group_id: class_group_id
+              }
+            end
+          else
+            class_definition.each do |key, nested_class_group|
+              process_classes_recursively(
+                nested_class_group,
+                get_class_part(class_part_object, key),
+                class_group_id,
+                theme
+              )
+            end
+          end
+        end
+      end
+
+      def get_class_part(class_part_object, path)
+        current_class_part_object = class_part_object
+
+        path.to_s.split(CLASS_PART_SEPARATOR).each do |path_part|
+          unless current_class_part_object[:next_part].key?(path_part)
+            current_class_part_object[:next_part][path_part] = {
+              next_part: {},
+              validators: []
+            }
+          end
+
+          current_class_part_object = current_class_part_object[:next_part][path_part]
+        end
+
+        current_class_part_object
+      end
+
+      def get_group_id_for_arbitrary_property(class_name)
+        match = ARBITRARY_PROPERTY_REGEX.match(class_name)
+        return unless match
+
+        property = match[1].to_s.split(":", 2).first
+
+        # Use two dots here because one dot is used as prefix for class groups in plugins
+        "arbitrary..#{property}" if property && !property.empty?
+      end
+
+      def from_theme?(validator)
+        TailwindConfig::VALID_THEME_IDS.include?(validator.object_id)
+      end
+    end
+  end
+end

data/lib/daisy_ui/class_merge/configuration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module ClassMerge
+    # Settings for DaisyUI::ClassMerge, reached through
+    # `DaisyUI.configure { |c| c.class_merge }`.
+    #
+    #   DaisyUI.configure do |c|
+    #     c.class_merge.enabled = true
+    #     c.class_merge.utility("text-display", "text-hero", like: "text-lg")
+    #     c.class_merge.theme(spacing: %w[gutter])
+    #   end
+    #
+    # Custom colors (`bg-brand`, `text-brand`) need no registration.
+    class Configuration
+      THEME_KEYS = TailwindConfig::DEFAULTS[:theme].keys.freeze
+
+      attr_accessor :enabled
+
+      def initialize
+        @enabled = true
+        @theme = {}
+        @class_groups = {}
+        @conflicts = {}
+      end
+
+      # Registers utilities that behave like an existing one:
+      # `utility("text-display", like: "text-lg")` makes `text-display` a font
+      # size, so it replaces `text-sm` and sits next to `text-error`.
+      def utility(*names, like:)
+        group = ClassMerge.tailwind_utils.class_group_id(like) or
+          raise ArgumentError, "#{like.inspect} is not a known utility to model #{names.join(', ')} on"
+
+        class_groups(group => names.map(&:to_s))
+      end
+
+      # Appends values to Tailwind theme scales, which feed every utility using
+      # the scale: `spacing: %w[gutter]` covers `p-gutter`, `m-gutter`, `gap-gutter`.
+      def theme(**scales)
+        scales = scales.transform_keys { |key| key.to_s.tr("_", "-") }
+        unknown = scales.keys - THEME_KEYS
+        raise ArgumentError, "unknown theme key #{unknown.map(&:inspect).join(', ')}; use one of #{THEME_KEYS.join(', ')}" if unknown.any?
+
+        append(@theme, scales.transform_values { |values| Array(values).map(&:to_s) })
+      end
+
+      # Raw tailwind_merge class groups: `{ "group-id" => ["class", ...] }`.
+      # Classes in the same group conflict with each other.
+      def class_groups(groups)
+        append(@class_groups, groups)
+      end
+
+      # Raw tailwind_merge conflicts: `{ "group-id" => ["other-group-id", ...] }`
+      # removes earlier classes of the listed groups when a class of the key
+      # group appears later.
+      def conflicts(conflicts)
+        append(@conflicts, conflicts)
+      end
+
+      # @api private The config passed to Merger.new, including the daisyUI groups.
+      def merger_config
+        {
+          theme: @theme,
+          class_groups: DaisyGroups.build.merge(@class_groups) { |_id, existing, added| existing + added },
+          conflicting_class_groups: @conflicts
+        }
+      end
+
+      private
+
+      def append(target, entries)
+        entries.each { |id, values| (target[id.to_s] ||= []).concat(Array(values)) }
+        ClassMerge.reset!
+      end
+    end
+  end
+end

data/lib/daisy_ui/class_merge/daisy_groups.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module ClassMerge
+    # Builds merger class groups from the modifier groups components declare:
+    #
+    #   register_modifiers(size: { sm: "btn-sm", lg: "btn-lg" })
+    #
+    # gives the group `daisy:group:btn-size` = ["btn-sm", "btn-lg"], so
+    # `btn-sm btn-lg` merges to `btn-lg`. Ungrouped modifiers never conflict.
+    # Tokens Tailwind already classifies (`bg-primary text-primary-content`)
+    # are left to the Tailwind groups, which resolve them per utility.
+    #
+    # Every gem component base class (`btn`, `table`) also gets a group of its
+    # own and is never dropped, even where Tailwind has a utility of the same
+    # name (`table`, `collapse`).
+    #
+    # @api private
+    module DaisyGroups
+      class << self
+        # Class groups for the merger: `{ "daisy:group:btn-size" => ["btn-xs", ...], ... }`.
+        def build(prefix: DaisyUI.configuration.prefix)
+          components = self.components
+          groups = {}
+
+          gem_components(components).each do |component|
+            next unless (base = component.component_class)
+
+            groups["daisy:base:#{base}"] = ["#{prefix}#{base}"]
+          end
+
+          components.each do |component|
+            component.modifier_groups.each do |group, members|
+              tokens = members.flat_map { |member| component.modifiers[member].to_s.split }
+              add(groups, "daisy:group:#{component.component_class || component.name}-#{group}", tokens, prefix)
+            end
+          end
+
+          # Configured modifiers join the component's own group of that name.
+          DaisyUI.configuration.modifiers.groups.each do |(component, group), classes|
+            owner = component ? component.component_class || component.name : "global"
+            add(groups, "daisy:group:#{owner}-#{group}", classes.flat_map(&:split), prefix)
+          end
+
+          groups
+        end
+
+        def tailwind_class?(token)
+          !ClassMerge.tailwind_utils.class_group_id(token).nil?
+        end
+
+        # Every named DaisyUI::Base subclass: the gem's components (eager
+        # loaded) and any app component loaded so far. An app component that
+        # loads later resets the merger through `register_modifiers`.
+        def components
+          Zeitwerk::Loader.eager_load_namespace(DaisyUI)
+          descendants(DaisyUI::Base).select(&:name)
+        end
+
+        # Only the gem's own base classes are protected: an app component's
+        # derived name (`UI::Grid` -> "grid") may well be a Tailwind utility.
+        def gem_components(components = self.components)
+          components.select { |component| component.name.start_with?("DaisyUI::") }
+        end
+
+        private
+
+        # Subclasses share their parent's component_class and group names, so
+        # their tokens land in the same group id and are unioned.
+        def add(groups, id, tokens, prefix)
+          tokens = tokens.reject { |token| tailwind_class?(token) }.map { |token| "#{prefix}#{token}" }
+          return if tokens.empty?
+
+          groups[id] = (groups[id] || []) | tokens
+        end
+
+        def descendants(klass)
+          klass.subclasses.flat_map { |subclass| [subclass, *descendants(subclass)] }
+        end
+      end
+    end
+  end
+end

data/lib/daisy_ui/class_merge/merger.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Ported from tailwind_merge 1.5.6 (https://github.com/gjtorikian/tailwind_merge)
+# Copyright (c) 2022 Garen J. Torikian. MIT License, see LICENSE-tailwind_merge.txt.
+
+module DaisyUI
+  module ClassMerge
+    class Merger
+      include TailwindConfig
+      include ParseClassName
+      include SortModifiers
+
+      def initialize(config: {})
+        @config = merge_config(config)
+        @class_utils = ClassGroupUtils.new(@config)
+        @cache = Cache.new(@config[:cache_size])
+        @postfix_lookup_class_group_ids = build_postfix_lookup_class_group_ids(@config[:postfix_lookup_class_groups])
+        @order_sensitive_modifiers = Set.new(@config[:order_sensitive_modifiers]).freeze
+      end
+
+      def merge(classes)
+        normalized = classes.is_a?(Array) ? classes.compact.join(" ") : classes.to_s
+
+        @cache.getset(normalized) do
+          merge_class_list(normalized).freeze
+        end
+      end
+
+      private
+
+      def merge_class_list(class_list)
+        # Set of class_group_ids in following format:
+        # `{importantModifier}{variantModifiers}{classGroupId}`
+        # @example 'float'
+        # @example 'hover:focus:bg-color'
+        # @example 'md:!pr'
+        class_names = class_list.split
+        return "" if class_names.empty?
+
+        class_groups_in_conflict = Set.new
+
+        merged_classes = []
+
+        class_names.reverse_each do |original_class_name|
+          result = parse_class_name(original_class_name, prefix: @config[:prefix])
+          is_external = result.is_external
+          modifiers = result.modifiers
+          has_important_modifier = result.has_important_modifier
+          base_class_name = result.base_class_name
+          maybe_postfix_modifier_position = result.maybe_postfix_modifier_position
+
+          if is_external
+            merged_classes.push(original_class_name)
+            next
+          end
+
+          has_postfix_modifier = maybe_postfix_modifier_position ? true : false
+
+          if has_postfix_modifier
+            # maybe_postfix_modifier_position is a byte offset (see ParseClassName)
+            base_class_name_without_postfix = base_class_name.byteslice(0, maybe_postfix_modifier_position)
+            class_group_id = @class_utils.class_group_id(base_class_name_without_postfix)
+
+            if class_group_id && @postfix_lookup_class_group_ids[class_group_id]
+              class_group_id_with_postfix = @class_utils.class_group_id(base_class_name)
+              if class_group_id_with_postfix && class_group_id_with_postfix != class_group_id
+                class_group_id = class_group_id_with_postfix
+                has_postfix_modifier = false
+              end
+            end
+          else
+            class_group_id = @class_utils.class_group_id(base_class_name)
+          end
+
+          unless class_group_id
+            unless has_postfix_modifier
+              # Not a Tailwind class
+              merged_classes << original_class_name
+              next
+            end
+
+            class_group_id = @class_utils.class_group_id(base_class_name)
+
+            unless class_group_id
+              # Not a Tailwind class
+              merged_classes << original_class_name
+              next
+            end
+
+            has_postfix_modifier = false
+          end
+
+          variant_modifier = sort_modifiers(modifiers, @order_sensitive_modifiers).join(":")
+
+          modifier_id = has_important_modifier ? "#{variant_modifier}#{IMPORTANT_MODIFIER}" : variant_modifier
+          has_modifier_id = !modifier_id.empty?
+          # `to_s` matches the previous interpolation behavior: group ids may be
+          # Symbols (custom configs) or Strings (defaults, where to_s is free)
+          class_id = has_modifier_id ? "#{modifier_id}#{class_group_id}" : class_group_id.to_s
+
+          # Tailwind class omitted due to conflict
+          next if class_groups_in_conflict.include?(class_id)
+
+          class_groups_in_conflict << class_id
+
+          @class_utils.get_conflicting_class_group_ids(class_group_id, has_postfix_modifier).each do |conflicting_id|
+            class_groups_in_conflict << (has_modifier_id ? "#{modifier_id}#{conflicting_id}" : conflicting_id.to_s)
+          end
+
+          # Tailwind class not in conflict
+          merged_classes << original_class_name
+        end
+
+        merged_classes.reverse!.join(" ")
+      end
+
+      def build_postfix_lookup_class_group_ids(class_group_ids)
+        lookup = {}
+        return lookup unless class_group_ids
+
+        class_group_ids.each { |id| lookup[id] = true }
+        lookup
+      end
+    end
+  end
+end