hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi/skeleton/image/component.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    module Image
-      class Component < Hakumi::BaseComponent
-        DEFAULT_ICON_NAME = "picture"
-        DEFAULT_ICON_THEME = :outlined
-        DEFAULT_ICON_SIZE = 48
-        ICON_SCALE = 0.55
-        MIN_ICON_SIZE = 32
-
-        def initialize(active: false, width: 96, height: 96, **html_options)
-          @active = active
-          @width = width
-          @height = height
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
-        end
-
-        def image_classes
-          class_names("skeleton-image")
-        end
-
-        def image_style
-          styles = []
-          styles << "width: #{dimension_to_css(@width)}" if @width
-          styles << "height: #{dimension_to_css(@height)}" if @height
-          styles.join("; ") if styles.any?
-        end
-
-        def icon_component_options
-          {
-            name: DEFAULT_ICON_NAME,
-            theme: DEFAULT_ICON_THEME,
-            size: calculated_icon_size,
-            color: "currentColor",
-            style: "line-height: 1"
-          }
-        end
-
-        private
-
-        def calculated_icon_size
-          dimension = [ numeric_dimension(@width), numeric_dimension(@height) ].compact.min
-          return DEFAULT_ICON_SIZE unless dimension
-
-          [ (dimension * ICON_SCALE).round, MIN_ICON_SIZE ].max
-        end
-
-        def numeric_dimension(value)
-          return value if value.is_a?(Numeric)
-          return value.to_f if value.is_a?(String) && value.strip.end_with?("px")
-
-          nil
-        end
-
-        def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
-        end
-
-        def validate_props!
-          validate_size!(:width, @width)
-          validate_size!(:height, @height)
-        end
-
-        def validate_size!(name, value)
-          return if value.nil? || value.is_a?(Numeric) || value.is_a?(String)
-
-          raise ArgumentError, "#{name} must be a number or string"
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/skeleton/input/component.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    module Input
-      class Component < Hakumi::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
-
-        def initialize(active: false, size: :default, block: false, **html_options)
-          @active = active
-          @size = normalize_size(size)
-          @block = block
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
-        end
-
-        def input_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && @size != :default
-
-          class_names("skeleton-input", modifiers)
-        end
-
-        private
-
-        def normalize_size(size)
-          size.to_sym
-        end
-
-        def wrapper_classes
-          class_names("skeleton", { element: true, active: @active, block: @block }, @html_options[:class])
-        end
-
-        def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size
-        end
-
-        def validate_inclusion_value(name, value, allowed)
-          return if allowed.include?(value)
-
-          raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/skeleton/node/component.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    module Node
-      class Component < Hakumi::BaseComponent
-        def initialize(active: false, size: 40, **html_options)
-          @active = active
-          @size = size
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
-        end
-
-        def node_classes
-          class_names("skeleton-node")
-        end
-
-        def node_style
-          return nil unless @size
-
-          "width: #{dimension_to_css(@size)}; height: #{dimension_to_css(@size)};"
-        end
-
-        private
-
-        def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
-        end
-
-        def validate_props!
-          return if @size.nil? || @size.is_a?(Numeric) || @size.is_a?(String)
-
-          raise ArgumentError, "size must be a number or string"
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/slider/component.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Slider
-    # Hakumi Slider component
-    # Supports single and range sliders with marks, dots, and vertical layout.
-    class Component < Hakumi::BaseComponent
-      include Hakumi::Concerns::FormField
-
-      def initialize(
-        name: nil,
-        label: nil,
-        caption: nil,
-        value: nil,
-        default_value: nil,
-        min: 0,
-        max: 100,
-        step: 1,
-        range: false,
-        vertical: false,
-        marks: nil,
-        dots: false,
-        tooltip_visible: nil,
-        keyboard: true,
-        disabled: false,
-        allow_cross: true,
-        handle_min: nil,
-        handle_max: nil,
-        standalone: true,
-        required: false,
-        errors: [],
-        **html_attrs
-      )
-        @name = name || generate_id("slider")
-        @label = label
-        @caption = caption
-        @value = value
-        @default_value = default_value
-        @min = min
-        @max = max
-        @step = step
-        @range = cast_boolean(range)
-        @vertical = cast_boolean(vertical)
-        @marks = normalize_marks(marks)
-        @dots = cast_boolean(dots)
-        @tooltip_visible = tooltip_visible
-        @keyboard = cast_boolean(keyboard)
-        @disabled = cast_boolean(disabled)
-        @allow_cross = cast_boolean(allow_cross)
-        @handle_min = handle_min
-        @handle_max = handle_max
-        @standalone = cast_boolean(standalone)
-        @required = cast_boolean(required)
-        @errors = Array(errors)
-        @html_attrs = html_attrs
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          {
-            class: component_html_class,
-            data: {
-              controller: "hakumi--slider",
-              "hakumi--slider-min-value": @min,
-              "hakumi--slider-max-value": @max,
-              "hakumi--slider-step-value": @step,
-              "hakumi--slider-range-value": @range,
-              "hakumi--slider-vertical-value": @vertical,
-              "hakumi--slider-disabled-value": @disabled,
-              "hakumi--slider-keyboard-value": @keyboard,
-              "hakumi--slider-allow-cross-value": @allow_cross,
-              "hakumi--slider-handle-min-value": handle_bounds_value(@handle_min),
-              "hakumi--slider-handle-max-value": handle_bounds_value(@handle_max),
-              "hakumi--slider-tooltip-visible-value": tooltip_visible_value,
-              "hakumi--slider-value-value": data_value(@value),
-              "hakumi--slider-default-value-value": data_value(@default_value)
-            }.compact
-          },
-          {
-            id: @html_attrs[:id],
-            data: @html_attrs[:data]
-          }.compact
-        )
-      end
-
-      def input_name
-        return @name unless @range
-        return @name if @name.to_s.end_with?("[]")
-
-        "#{@name}[]"
-      end
-
-      def input_id_for(index)
-        return input_id unless @range
-
-        "#{input_id}_#{index}"
-      end
-
-      def handle_count
-        @range ? 2 : 1
-      end
-
-      def marks?
-        @marks.any?
-      end
-
-      def mark_style(value)
-        percent = position_percent(value)
-        if @vertical
-          "bottom: #{percent}%"
-        else
-          "left: #{percent}%"
-        end
-      end
-
-      def dot_values
-        return [] unless @dots
-
-        min = @min.to_f
-        max = @max.to_f
-        step = @step.to_f
-        return [] if step <= 0
-
-        values = []
-        current = min
-        while current <= max + (step / 1000.0)
-          values << current
-          current += step
-        end
-        values
-      end
-
-      private
-
-      def validate_props!
-        validate_numeric_like!(@min, "min")
-        validate_numeric_like!(@max, "max")
-        validate_numeric_like!(@step, "step")
-
-        validate_range_values!(@value, "value") if @value
-        validate_range_values!(@default_value, "default_value") if @default_value
-      end
-
-      def validate_numeric_like!(value, name)
-        return if value.is_a?(Numeric) || value.is_a?(String)
-
-        raise ArgumentError, "#{name} must be a number or string"
-      end
-
-      def validate_range_values!(value, name)
-        if @range
-          unless value.is_a?(Array) && value.size == 2
-            raise ArgumentError, "#{name} must be an array of two values when range is true"
-          end
-        elsif value.is_a?(Array)
-          raise ArgumentError, "#{name} must be a single value when range is false"
-        end
-      end
-
-      def component_html_class
-        class_names(
-          "slider",
-          {
-            range: @range,
-            vertical: @vertical,
-            disabled: @disabled,
-            "with-marks": marks?,
-            "with-dots": @dots,
-            "tooltip-visible": tooltip_visible_class?
-          },
-          @html_attrs[:wrapper_class]
-        )
-      end
-
-      def tooltip_visible_class?
-        @tooltip_visible == true
-      end
-
-      def tooltip_visible_value
-        return nil if @tooltip_visible.nil?
-
-        cast_boolean(@tooltip_visible)
-      end
-
-      def data_value(value)
-        return nil if value.nil?
-
-        Array(value).to_json
-      end
-
-      def handle_bounds_value(value)
-        return nil if value.nil?
-
-        Array(value).to_json
-      end
-
-      def normalize_marks(marks)
-        return [] if marks.nil?
-
-        entries = if marks.is_a?(Hash)
-                    marks.map { |value, label| { value: value, label: label } }
-        else
-                    Array(marks).map do |mark|
-                      if mark.is_a?(Hash)
-                        value = mark[:value] || mark["value"]
-                        label = mark[:label] || mark["label"] || value
-                        { value: value, label: label }
-                      else
-                        { value: mark, label: mark }
-                      end
-                    end
-        end
-
-        entries.compact.select { |entry| entry[:value].present? }.sort_by { |entry| entry[:value].to_f }
-      end
-
-      def position_percent(value)
-        min = @min.to_f
-        max = @max.to_f
-        return 0 if max == min
-
-        ((value.to_f - min) / (max - min) * 100).clamp(0, 100)
-      end
-    end
-  end
-end

data/app/components/hakumi/space/compact/component.html.erb

@@ -1,3 +0,0 @@
-<div <%= tag.attributes(html_attributes) %>>
-  <%= content %>
-</div>

data/app/components/hakumi/space/compact/component.rb

@@ -1,36 +0,0 @@
-module Hakumi
-  module Space
-    module Compact
-      class Component < ViewComponent::Base
-        def initialize(direction: :horizontal, block: false, **html_options)
-          @direction = direction
-          @block = block
-          @html_options = html_options
-        end
-
-        private
-
-        def html_attributes
-          attrs = @html_options.dup
-          attrs[:class] = css_classes
-          attrs[:style] = inline_styles
-          attrs
-        end
-
-        def css_classes
-          classes = [ "hakumi-space-compact" ]
-          classes << "hakumi-space-compact-#{@direction}"
-          classes << "hakumi-space-compact-block" if @block
-          classes << @html_options[:class] if @html_options[:class]
-          classes.join(" ")
-        end
-
-        def inline_styles
-          styles = []
-          styles << @html_options[:style] if @html_options[:style]
-          styles.join("; ")
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/space/component.rb

@@ -1,73 +0,0 @@
-module Hakumi
-  module Space
-    class Component < ViewComponent::Base
-      renders_many :items, "ItemComponent"
-
-      def initialize(direction: :horizontal, size: :small, align: nil, wrap: false, block: false, split: nil, **html_options)
-        @direction = direction
-        @size = size
-        @align = align
-        @wrap = wrap
-        @block = block
-        @split = split
-        @html_options = html_options
-      end
-
-      attr_reader :split
-
-      private
-
-      def html_attributes
-        attrs = @html_options.dup
-        attrs[:class] = css_classes
-        attrs[:style] = inline_styles
-        attrs
-      end
-
-      def css_classes
-        classes = [ "hakumi-space" ]
-        classes << "hakumi-space-#{@direction}"
-        classes << "hakumi-space-align-#{@align}" if @align
-        classes << "hakumi-space-wrap" if @wrap
-        classes << "hakumi-space-block" if @block
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
-      end
-
-      def inline_styles
-        styles = []
-
-        gap_size = case @size
-        when :small then "8px"
-        when :middle then "16px"
-        when :large then "24px"
-        when Integer then "#{@size}px"
-        else "8px"
-        end
-
-        styles << "gap: #{gap_size}"
-        styles << @html_options[:style] if @html_options[:style]
-        styles.join("; ")
-      end
-
-      def call
-        return nil if items.empty?
-
-        safe_join(items.map { |item| content_tag(:div, item, class: "hakumi-space-item") }, split_content)
-      end
-
-      private
-
-      def split_content
-        return nil unless @split
-
-        content_tag(:div, @split, class: "hakumi-space-split")
-      end
-      class ItemComponent < ViewComponent::Base
-        def call
-          content_tag(:div, content, class: "hakumi-space-item")
-        end
-      end
-    end
-  end
-end