playbook_ui 16.5.0.pre.rc.3 → 16.5.0.pre.rc.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50ca8e58f947f8dbec4fc7f659410b09588f9b11d0404c18824a67866c5773e7
-  data.tar.gz: d3e1e785a1f9b4f24910a199890f6c8342a5a479f7a3ec948d0f9bed0d88fed4
+  metadata.gz: e7dea3b3ac4ba79818f434283562129d10590e6ba4fed204f8c88044ef625cc8
+  data.tar.gz: 18d7def47926195b0e20252fded19e19151195881053f7260e583381523f6f3a
 SHA512:
-  metadata.gz: cb09d5d1204fb4929189c91eab464aec3e55257119016aacf4c307a93a7b5626026a633e69905b17ea8c1f9f81e391e8311919fae5bab6f9a2ff6e53f83ff454
-  data.tar.gz: 1a84b06d8c5943f8466234897a3218b27ff344ed65bdc0a96b67a0aa74d6337040ebff422ebcfae70d1cf4fb20b3e5a64ca5975e97d9f70a3878b6248bc0f246
+  metadata.gz: a749f50a68169e51b59ed941540f001800ab1e9627541a0a63aa14cc8dc8233ecddfb06a1aafaec2d675bd3911259acb8f336526100e03f3bcb246f6ef20ea81
+  data.tar.gz: 51b2b301c0b38f264cabda4c45c6f3296872075e0bbdbbae636c3bebaf33d9082bf67a7dce9f01e1c4035564239b7f93926ced594b2509e3e8600970f9a8b0a9

data/lib/playbook/align_content.rb

@@ -6,42 +6,31 @@ module Playbook
       base.prop :align_content
     end
 
-    # rubocop:disable Style/IfInsideElse
-    def align_content_props
-      selected_props = align_content_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      screen_size_values = %w[xs sm md lg xl]
-
-      selected_props.map do |k|
-        align_content = send(k)
-        if align_content.is_a?(Hash)
-          class_result = []
+    ALIGN_CONTENT_VALUES = %w[start end center spaceBetween spaceAround spaceEvenly].freeze
+    SCREEN_SIZES = %w[xs sm md lg xl].freeze
 
-          # Handle default value separately (generates base class without size prefix)
-          class_result << "align_content_#{align_content[:default].underscore}" if align_content.key?(:default) && align_content_values.include?(align_content[:default])
-
-          # Handle responsive sizes (generates classes with size prefix)
-          align_content.each do |media_size, align_value|
-            class_result << "align_content_#{media_size}_#{align_value.underscore}" if screen_size_values.include?(media_size.to_s) && align_content_values.include?(align_value)
-          end
-
-          class_result
-        else
-          "align_content_#{align_content.underscore}" if align_content_values.include? align_content
+    def align_content_props
+      value = align_content
+      return nil unless value
+
+      if value.is_a?(::Hash)
+        css = +""
+        css << "align_content_#{value[:default].underscore} " if value.key?(:default) && ALIGN_CONTENT_VALUES.include?(value[:default])
+        value.each do |media_size, align_value|
+          css << "align_content_#{media_size}_#{align_value.underscore} " if SCREEN_SIZES.include?(media_size.to_s) && ALIGN_CONTENT_VALUES.include?(align_value)
         end
-      end.flatten.compact.join(" ")
+        css.strip unless css.empty?
+      elsif ALIGN_CONTENT_VALUES.include?(value)
+        "align_content_#{value.underscore}"
+      end
     end
-    # rubocop:enable Style/IfInsideElse
 
     def align_content_options
-      {
-        align_content: "align_content",
-      }
+      { align_content: "align_content" }
     end
 
     def align_content_values
-      %w[start end center spaceBetween spaceAround spaceEvenly]
+      ALIGN_CONTENT_VALUES
     end
   end
 end

data/lib/playbook/align_items.rb

@@ -6,42 +6,31 @@ module Playbook
       base.prop :align_items
     end
 
-    # rubocop:disable Style/IfInsideElse
-    def align_items_props
-      selected_props = align_items_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      screen_size_values = %w[xs sm md lg xl]
-
-      selected_props.map do |k|
-        align_items_value = send(k)
-        if align_items_value.is_a?(Hash)
-          class_result = []
+    ALIGN_ITEMS_VALUES = %w[flexStart flexEnd start end center baseline stretch].freeze
+    SCREEN_SIZES = %w[xs sm md lg xl].freeze
 
-          # Handle default value separately (generates base class without size prefix)
-          class_result << "align_items_#{align_items_value[:default].underscore}" if align_items_value.key?(:default) && align_items_values.include?(align_items_value[:default].to_s)
-
-          # Handle responsive sizes (generates classes with size prefix)
-          align_items_value.each do |media_size, align_value|
-            class_result << "align_items_#{media_size}_#{align_value.underscore}" if screen_size_values.include?(media_size.to_s) && align_items_values.include?(align_value.to_s)
-          end
-
-          class_result
-        else
-          "align_items_#{align_items_value.underscore}" if align_items_values.include? align_items_value
+    def align_items_props
+      value = align_items
+      return nil unless value
+
+      if value.is_a?(::Hash)
+        css = +""
+        css << "align_items_#{value[:default].underscore} " if value.key?(:default) && ALIGN_ITEMS_VALUES.include?(value[:default].to_s)
+        value.each do |media_size, align_value|
+          css << "align_items_#{media_size}_#{align_value.underscore} " if SCREEN_SIZES.include?(media_size.to_s) && ALIGN_ITEMS_VALUES.include?(align_value.to_s)
         end
-      end.flatten.compact.join(" ")
+        css.strip unless css.empty?
+      elsif ALIGN_ITEMS_VALUES.include?(value)
+        "align_items_#{value.underscore}"
+      end
     end
-    # rubocop:enable Style/IfInsideElse
 
     def align_items_options
-      {
-        align_items: "align_items",
-      }
+      { align_items: "align_items" }
     end
 
     def align_items_values
-      %w[flexStart flexEnd start end center baseline stretch]
+      ALIGN_ITEMS_VALUES
     end
   end
 end

data/lib/playbook/align_self.rb

@@ -6,42 +6,31 @@ module Playbook
       base.prop :align_self
     end
 
-    # rubocop:disable Style/IfInsideElse
-    def align_self_props
-      selected_props = align_self_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      screen_size_values = %w[xs sm md lg xl]
-
-      selected_props.map do |k|
-        align_self_value = send(k)
-        if align_self_value.is_a?(Hash)
-          class_result = []
+    ALIGN_SELF_VALUES = %w[auto start end center stretch baseline].freeze
+    SCREEN_SIZES = %w[xs sm md lg xl].freeze
 
-          # Handle default value separately (generates base class without size prefix)
-          class_result << "align_self_#{align_self_value[:default]}" if align_self_value.key?(:default) && align_self_values.include?(align_self_value[:default])
-
-          # Handle responsive sizes (generates classes with size prefix)
-          align_self_value.each do |media_size, align_value|
-            class_result << "align_self_#{media_size}_#{align_value}" if screen_size_values.include?(media_size.to_s) && align_self_values.include?(align_value)
-          end
-
-          class_result
-        else
-          "align_self_#{align_self_value}" if align_self_values.include? align_self_value
+    def align_self_props
+      value = align_self
+      return nil unless value
+
+      if value.is_a?(::Hash)
+        css = +""
+        css << "align_self_#{value[:default]} " if value.key?(:default) && ALIGN_SELF_VALUES.include?(value[:default])
+        value.each do |media_size, align_value|
+          css << "align_self_#{media_size}_#{align_value} " if SCREEN_SIZES.include?(media_size.to_s) && ALIGN_SELF_VALUES.include?(align_value)
         end
-      end.flatten.compact.join(" ")
-      # rubocop:enable Style/IfInsideElse
+        css.strip unless css.empty?
+      elsif ALIGN_SELF_VALUES.include?(value)
+        "align_self_#{value}"
+      end
     end
 
     def align_self_options
-      {
-        align_self: "align_self",
-      }
+      { align_self: "align_self" }
     end
 
     def align_self_values
-      %w[auto start end center stretch baseline]
+      ALIGN_SELF_VALUES
     end
   end
 end

data/lib/playbook/border_radius.rb

@@ -6,24 +6,21 @@ module Playbook
       base.prop :border_radius
     end
 
+    BORDER_RADIUS_VALUES = %w[none xs sm md lg xl rounded].freeze
+
     def border_radius_props
-      selected_props = border_radius_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
+      value = border_radius
+      return nil unless value
 
-      selected_props.map do |k|
-        border_radius_value = send(k)
-        "border_radius_#{border_radius_value}" if border_radius_values.include? border_radius_value
-      end.compact.join(" ")
+      "border_radius_#{value}" if BORDER_RADIUS_VALUES.include?(value)
     end
 
     def border_radius_options
-      {
-        border_radius: "border_radius",
-      }
+      { border_radius: "border_radius" }
     end
 
     def border_radius_values
-      %w[none xs sm md lg xl rounded]
+      BORDER_RADIUS_VALUES
     end
   end
 end

data/lib/playbook/bottom.rb

@@ -10,27 +10,23 @@ module Playbook
       base.prop :bottom
     end
 
+    BOTTOM_VALUES = %w[0 xxs xs sm md lg xl auto initial inherit].freeze
+
     def bottom_values
-      %w[0 xxs xs sm md lg xl auto initial inherit]
+      BOTTOM_VALUES
     end
 
     def bottom_options
-      {
-        bottom: "bottom",
-      }
+      { bottom: "bottom" }
     end
 
   private
 
     def bottom_props
-      selected_props = bottom_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      selected_props.map do |k|
-        value = send(k)
-        css = positioning_css("bottom", value) if bottom.present?
-        css
-      end.compact.join(" ")
+      value = bottom
+      return nil unless value
+
+      positioning_css("bottom", value)
     end
   end
 end

data/lib/playbook/classnames.rb

@@ -8,62 +8,78 @@ module Playbook
     end
 
     def generate_classname(*name_parts, separator: "_")
-      [
-        name_parts.compact.join(separator),
-        prop(:classname),
-        spacing_props,
-        dark_props,
-        width_props,
-        min_width_props,
-        max_width_props,
-        gap_props,
-        column_gap_props,
-        row_gap_props,
-        z_index_props,
-        number_spacing_props,
-        shadow_props,
-        line_height_props,
-        display_props,
-        cursor_props,
-        flex_direction_props,
-        flex_wrap_props,
-        justify_content_props,
-        justify_self_props,
-        align_items_props,
-        align_content_props,
-        align_self_props,
-        flex_props,
-        flex_grow_props,
-        flex_shrink_props,
-        order_props,
-        position_props,
-        hover_props,
-        border_radius_props,
-        text_align_props,
-        overflow_props,
-        truncate_props,
-        left_props,
-        top_props,
-        right_props,
-        bottom_props,
-        vertical_align_props,
-        height_props,
-        min_height_props,
-        max_height_props,
-      ].compact.join(" ")
+      css = +name_parts.compact.join(separator)
+      append_classname(css, prop(:classname))
+
+      # Spacing props (handles margin, padding, and width sub-props)
+      append_classname(css, spacing_props)
+      css << " dark" if dark
+      append_classname(css, width_props)
+      append_classname(css, min_width_props)
+      append_classname(css, max_width_props)
+
+      # Gap utilities
+      append_classname(css, gap_props)
+      append_classname(css, column_gap_props)
+      append_classname(css, row_gap_props)
+
+      # Single-value utilities
+      append_classname(css, z_index_props)
+      append_classname(css, number_spacing_props)
+      append_classname(css, shadow_props)
+      append_classname(css, line_height_props)
+      append_classname(css, display_props)
+      append_classname(css, cursor_props)
+
+      # Flex utilities
+      append_classname(css, flex_direction_props)
+      append_classname(css, flex_wrap_props)
+      append_classname(css, justify_content_props)
+      append_classname(css, justify_self_props)
+      append_classname(css, align_items_props)
+      append_classname(css, align_content_props)
+      append_classname(css, align_self_props)
+      append_classname(css, flex_props)
+      append_classname(css, flex_grow_props)
+      append_classname(css, flex_shrink_props)
+      append_classname(css, order_props)
+
+      # Position and layout
+      append_classname(css, position_props)
+      append_classname(css, hover_props)
+      append_classname(css, border_radius_props)
+      append_classname(css, text_align_props)
+      append_classname(css, overflow_props)
+      append_classname(css, truncate_props)
+      append_classname(css, left_props)
+      append_classname(css, top_props)
+      append_classname(css, right_props)
+      append_classname(css, bottom_props)
+      append_classname(css, vertical_align_props)
+
+      # Height utilities
+      append_classname(css, height_props)
+      append_classname(css, min_height_props)
+      append_classname(css, max_height_props)
+      css
     end
 
     def generate_classname_without_spacing(*name_parts, separator: "_")
-      [
-        name_parts.compact.join(separator),
-        prop(:classname),
-      ].compact.join(" ")
+      css = +name_parts.compact.join(separator)
+      append_classname(css, prop(:classname))
+      css
     end
 
-  private
-
     def dark_props
       dark ? "dark" : nil
     end
+
+  private
+
+    # Appends a CSS class string to the accumulator if the value is present.
+    # Used by generate_classname to conditionally add utility prop classes.
+    def append_classname(css, value)
+      css << " " << value if value
+    end
   end
 end

data/lib/playbook/cursor.rb

@@ -6,24 +6,21 @@ module Playbook
       base.prop :cursor
     end
 
+    CURSOR_VALUES = %w[auto default none contextMenu help pointer progress wait cell crosshair text verticalText alias copy move noDrop notAllowed grab grabbing eResize nResize neResize nwResize sResize seResize swResize wResize ewResize nsResize neswResize nwseResize colResize rowResize allScroll zoomIn zoomOut].freeze
+
     def cursor_props
-      selected_props = cursor_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
+      value = cursor
+      return nil unless value
 
-      selected_props.map do |k|
-        cursor_value = send(k)
-        "cursor_#{cursor_value.underscore}" if cursor_values.include? cursor_value
-      end.compact.join(" ")
+      "cursor_#{value.underscore}" if CURSOR_VALUES.include?(value)
     end
 
     def cursor_options
-      {
-        cursor: "cursor",
-      }
+      { cursor: "cursor" }
     end
 
     def cursor_values
-      %w[auto default none contextMenu help pointer progress wait cell crosshair text verticalText alias copy move noDrop notAllowed grab grabbing eResize nResize neResize nwResize sResize seResize swResize wResize ewResize nsResize neswResize nwseResize colResize rowResize allScroll zoomIn zoomOut]
+      CURSOR_VALUES
     end
   end
 end

data/lib/playbook/display.rb

@@ -6,41 +6,35 @@ module Playbook
       base.prop :display
     end
 
-    def display_props
-      selected_props = display_options.keys.select { |sk| try(sk) }
-      responsive = selected_props.present? && try(:display).is_a?(::Hash)
-      css = ""
-      if responsive
-        display_value = send(:display)
+    DISPLAY_VALUES = %w[block inline_block inline flex inline_flex none grid].freeze
+    DISPLAY_SIZE_VALUES = %w[xs sm md lg xl].freeze
 
-        # Handle default value separately (generates base class without size prefix)
-        css += "display_#{display_value[:default]} " if display_value.key?(:default) && display_values.include?(display_value[:default].to_s)
+    def display_props
+      value = display
+      return nil unless value
 
-        # Handle responsive sizes (generates classes with size prefix)
-        display_value.each do |key, value|
-          css += "display_#{key}_#{value} " if display_size_values.include?(key.to_s) && display_values.include?(value.to_s)
-        end
-      else
-        selected_props.each do |k|
-          display_value = send(k)
-          css += "display_#{display_value}" if display_values.include?(display_value)
+      if value.is_a?(::Hash)
+        css = +""
+        css << "display_#{value[:default]} " if value.key?(:default) && DISPLAY_VALUES.include?(value[:default].to_s)
+        value.each do |key, val|
+          css << "display_#{key}_#{val} " if DISPLAY_SIZE_VALUES.include?(key.to_s) && DISPLAY_VALUES.include?(val.to_s)
         end
+        css.strip unless css.empty?
+      elsif DISPLAY_VALUES.include?(value)
+        "display_#{value}"
       end
-      css unless css.blank?
     end
 
     def display_options
-      {
-        display: "display",
-      }
+      { display: "display" }
     end
 
     def display_size_values
-      %w[xs sm md lg xl]
+      DISPLAY_SIZE_VALUES
     end
 
     def display_values
-      %w[block inline_block inline flex inline_flex none grid]
+      DISPLAY_VALUES
     end
   end
 end

data/lib/playbook/flex.rb

@@ -6,42 +6,31 @@ module Playbook
       base.prop :flex
     end
 
-    # rubocop:disable Style/IfInsideElse
-    def flex_props
-      selected_props = flex_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      screen_size_values = %w[xs sm md lg xl]
-
-      selected_props.map do |k|
-        flex_value = send(k)
-        if flex_value.is_a?(Hash)
-          class_result = []
+    FLEX_VALUES = %w[auto initial 0 1 2 3 4 5 6 7 8 9 10 11 12 none].freeze
+    SCREEN_SIZES = %w[xs sm md lg xl].freeze
 
-          # Handle default value separately (generates base class without size prefix)
-          class_result << "flex_#{flex_value[:default]}" if flex_value.key?(:default) && flex_values.include?(flex_value[:default].to_s)
-
-          # Handle responsive sizes (generates classes with size prefix)
-          flex_value.each do |media_size, value|
-            class_result << "flex_#{media_size}_#{value}" if screen_size_values.include?(media_size.to_s) && flex_values.include?(value.to_s)
-          end
-
-          class_result
-        else
-          "flex_#{flex_value}" if flex_values.include? flex_value.to_s
+    def flex_props
+      value = flex
+      return nil unless value
+
+      if value.is_a?(::Hash)
+        css = +""
+        css << "flex_#{value[:default]} " if value.key?(:default) && FLEX_VALUES.include?(value[:default].to_s)
+        value.each do |media_size, val|
+          css << "flex_#{media_size}_#{val} " if SCREEN_SIZES.include?(media_size.to_s) && FLEX_VALUES.include?(val.to_s)
         end
-      end.flatten.compact.join(" ")
+        css.strip unless css.empty?
+      elsif FLEX_VALUES.include?(value.to_s)
+        "flex_#{value}"
+      end
     end
-    # rubocop:enable Style/IfInsideElse
 
     def flex_options
-      {
-        flex: "flex",
-      }
+      { flex: "flex" }
     end
 
     def flex_values
-      %w[auto initial 0 1 2 3 4 5 6 7 8 9 10 11 12 none]
+      FLEX_VALUES
     end
   end
 end

data/lib/playbook/flex_direction.rb

@@ -6,42 +6,31 @@ module Playbook
       base.prop :flex_direction
     end
 
-    # rubocop:disable Style/IfInsideElse
-    def flex_direction_props
-      selected_props = flex_direction_options.keys.select { |sk| try(sk) }
-      return nil unless selected_props.present?
-
-      screen_size_values = %w[xs sm md lg xl]
-
-      selected_props.map do |k|
-        flex_direction_value = send(k)
-        if flex_direction_value.is_a?(Hash)
-          class_result = []
+    FLEX_DIRECTION_VALUES = %w[row column rowReverse columnReverse].freeze
+    SCREEN_SIZES = %w[xs sm md lg xl].freeze
 
-          # Handle default value separately (generates base class without size prefix)
-          class_result << "flex_direction_#{flex_direction_value[:default].underscore}" if flex_direction_value.key?(:default) && flex_direction_values.include?(flex_direction_value[:default])
-
-          # Handle responsive sizes (generates classes with size prefix)
-          flex_direction_value.each do |media_size, flex_value|
-            class_result << "flex_direction_#{media_size}_#{flex_value.underscore}" if screen_size_values.include?(media_size.to_s) && flex_direction_values.include?(flex_value)
-          end
-
-          class_result
-        else
-          "flex_direction_#{flex_direction_value.underscore}" if flex_direction_values.include? flex_direction_value
+    def flex_direction_props
+      value = flex_direction
+      return nil unless value
+
+      if value.is_a?(::Hash)
+        css = +""
+        css << "flex_direction_#{value[:default].underscore} " if value.key?(:default) && FLEX_DIRECTION_VALUES.include?(value[:default])
+        value.each do |media_size, flex_value|
+          css << "flex_direction_#{media_size}_#{flex_value.underscore} " if SCREEN_SIZES.include?(media_size.to_s) && FLEX_DIRECTION_VALUES.include?(flex_value)
         end
-      end.flatten.compact.join(" ")
+        css.strip unless css.empty?
+      elsif FLEX_DIRECTION_VALUES.include?(value)
+        "flex_direction_#{value.underscore}"
+      end
     end
-    # rubocop:enable Style/IfInsideElse
 
     def flex_direction_options
-      {
-        flex_direction: "flex_direction",
-      }
+      { flex_direction: "flex_direction" }
     end
 
     def flex_direction_values
-      %w[row column rowReverse columnReverse]
+      FLEX_DIRECTION_VALUES
     end
   end
 end