hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi/float_button/group_cluster/component.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module FloatButton
-    module GroupCluster
-      class Component < Hakumi::BaseComponent
-        DIRECTIONS = [ :horizontal, :vertical ].freeze
-        GAP_SIZES = {
-          small: "8px",
-          middle: "16px",
-          large: "24px"
-        }.freeze
-
-        PLACEMENTS = Hakumi::FloatButton::Component::PLACEMENTS
-
-        def initialize(
-          groups:,
-          placement: :bottom_right,
-          offset: nil,
-          direction: :horizontal,
-          gap: :middle,
-          floating: true,
-          **html_options
-        )
-          @groups = Array(groups)
-          @placement = placement
-          @offset = offset
-          @direction = direction
-          @gap = gap
-          @floating = floating
-          @html_options = html_options
-
-          validate_inclusion!(:direction, DIRECTIONS)
-          validate_inclusion!(:placement, PLACEMENTS.keys)
-          validate_gap_symbol!
-        end
-
-        def call
-          return "" if @groups.empty?
-
-          content_tag(:div, cluster_attributes) do
-            safe_join(@groups.map { |group_attrs| render_group(group_attrs) })
-          end
-        end
-
-        private
-
-        def cluster_attributes
-          base_attrs = {
-            class: class_names(
-              "float-button-group-cluster",
-              {
-                "direction-#{@direction}": true,
-                static: !@floating
-              }
-            )
-          }
-
-          style_value = cluster_style
-          base_attrs[:style] = style_value if style_value.present?
-
-          merge_attributes(base_attrs, @html_options.except(:data)).tap do |attrs|
-            attrs[:data] = @html_options[:data] if @html_options[:data]
-          end
-        end
-
-        def cluster_style
-          styles = [ placement_style, gap_style ].compact
-          styles.join("; ").presence
-        end
-
-        def placement_style
-          return nil unless @floating
-
-          resolved = resolved_offset
-          segments = [ "position: fixed", "z-index: 1000" ]
-          resolved.each { |key, value| segments << "#{key}: #{dimension(value)}" }
-          segments.join("; ")
-        end
-
-        def gap_style
-          value = case @gap
-          when Symbol then GAP_SIZES[@gap]
-          when Numeric then "#{@gap}px"
-          else @gap
-          end
-
-          return nil if value.blank?
-
-          "gap: #{value}"
-        end
-
-        def resolved_offset
-          placement_offset = PLACEMENTS[@placement] || PLACEMENTS[:bottom_right]
-          custom_offset = @offset || {}
-          placement_offset.merge(custom_offset).compact
-        end
-
-        def dimension(value)
-          return value if value.is_a?(String)
-
-          "#{value}px"
-        end
-
-        def render_group(group_spec)
-          content_tag(:div, class: "hakumi-float-button-group-cluster-item") do
-            render_group_content(group_spec)
-          end
-        end
-
-        def render_group_content(group_spec)
-          return render(group_spec) if renderable_component?(group_spec)
-          return render_group_content(group_spec.call) if group_spec.respond_to?(:call)
-
-          unless group_spec.is_a?(Hash)
-            raise ArgumentError, "Expected group definition to be a Hash or renderable component"
-          end
-
-          normalized = group_spec.deep_symbolize_keys
-          content_block = normalized.delete(:content)
-
-          normalized[:floating] = false unless normalized.key?(:floating)
-
-          component = Hakumi::FloatButton::Group::Component.new(**normalized)
-          content_block ? render(component, &content_block) : render(component)
-        end
-
-        def renderable_component?(object)
-          object.respond_to?(:render_in)
-        end
-
-        def validate_gap_symbol!
-          return unless @gap.is_a?(Symbol)
-
-          valid_keys = GAP_SIZES.keys
-          raise ArgumentError, "gap must be one of #{valid_keys.inspect}, got #{@gap.inspect}" unless valid_keys.include?(@gap)
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/grid/col/component.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Grid
-    module Col
-      class Component < Hakumi::BaseComponent
-        def initialize(
-          span: nil,
-          offset: nil,
-          order: nil,
-          pull: nil,
-          push: nil,
-          flex: nil,
-          xs: nil,
-          sm: nil,
-          md: nil,
-          lg: nil,
-          xl: nil,
-          xxl: nil,
-          component: :div,
-          **html_options
-        )
-          @span = span
-          @offset = offset
-          @order = order
-          @pull = pull
-          @push = push
-          @flex = flex
-          @breakpoints = { xs: xs, sm: sm, md: md, lg: lg, xl: xl, xxl: xxl }
-          @component = component
-          @html_options = html_options
-        end
-
-        def call
-          content_tag(@component, content, wrapper_attributes)
-        end
-
-        private
-
-        def wrapper_classes
-          classes = [ "hakumi-col" ]
-
-          # Base props
-          classes << "hakumi-col-#{@span}" if @span
-          classes << "hakumi-col-offset-#{@offset}" if @offset
-          classes << "hakumi-col-order-#{@order}" if @order
-          classes << "hakumi-col-pull-#{@pull}" if @pull
-          classes << "hakumi-col-push-#{@push}" if @push
-
-          # Responsive props
-          @breakpoints.each do |size, value|
-            next if value.nil?
-
-            if value.is_a?(Numeric)
-              classes << "hakumi-col-#{size}-#{value}"
-            elsif value.is_a?(Hash)
-              value.each do |prop, val|
-                prefix = prop == :span ? "hakumi-col-#{size}" : "hakumi-col-#{size}-#{prop}"
-                classes << "#{prefix}-#{val}"
-              end
-            end
-          end
-
-          class_names(nil, {}, [ classes, @html_options[:class] ])
-        end
-
-        def wrapper_attributes
-          combined_style = [ @html_options[:style], flex_style ].compact.join(";")
-          attrs = {
-            class: wrapper_classes
-          }
-          attrs[:style] = combined_style if combined_style.present?
-
-          merge_attributes(attrs, @html_options.except(:class, :style))
-        end
-
-        def flex_style
-          return nil unless @flex
-
-          style = []
-          if @flex.is_a?(Numeric)
-            style << "flex: #{@flex} #{@flex} auto"
-          elsif @flex == "auto"
-            style << "flex: 1 1 auto"
-          elsif @flex == "none"
-            style << "flex: 0 0 auto"
-          else
-            style << "flex: #{@flex}"
-          end
-
-          # Merge with existing style
-          existing_style = @html_options[:style]
-          [ existing_style, style.join(";") ].compact.join(";")
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/grid/row/component.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Grid
-    module Row
-      class Component < Hakumi::BaseComponent
-        JUSTIFY_OPTIONS = [ :start, :end, :center, :"space-around", :"space-between" ].freeze
-        ALIGN_OPTIONS = [ :top, :middle, :bottom ].freeze
-
-        def initialize(
-          gutter: 0,
-          justify: :start,
-          align: :top,
-          wrap: true,
-          component: :div,
-          **html_options
-        )
-          @gutter = normalize_gutter(gutter)
-          @justify = justify
-          @align = align
-          @wrap = wrap
-          @component = component
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def call
-          content_tag(@component, content, wrapper_attributes)
-        end
-
-        private
-
-        def validate_props!
-          validate_inclusion!(:justify, JUSTIFY_OPTIONS)
-          validate_inclusion!(:align, ALIGN_OPTIONS)
-        end
-
-        def normalize_gutter(gutter)
-          return [ 0, 0 ] if gutter.nil?
-          return [ gutter, gutter ] if gutter.is_a?(Numeric)
-          return gutter if gutter.is_a?(Array) && gutter.size == 2
-          [ 0, 0 ]
-        end
-
-        def wrapper_classes
-          class_names(
-            "row",
-            {
-              "no-wrap": !@wrap,
-              "justify-#{@justify}": @justify != :start,
-              "align-#{@align}": @align != :top
-            },
-            [ @html_options[:class] ]
-          )
-        end
-
-        def wrapper_attributes
-          attrs = {
-            class: wrapper_classes,
-            style: gutter_styles
-          }
-          merge_attributes(attrs, @html_options.except(:class, :style))
-        end
-
-        def gutter_styles
-          x, y = @gutter
-          styles = []
-          styles << "--row-gutter-x: #{x}px" if x > 0
-          styles << "--row-gutter-y: #{y}px" if y > 0
-
-          # Merge with existing style if present
-          existing_style = @html_options[:style]
-          [ existing_style, styles.join(";") ].compact.join(";")
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Image
-    class Component < Hakumi::BaseComponent
-      def initialize(
-        src:,
-        alt: nil,
-        width: nil,
-        height: nil,
-        fallback: nil,
-        placeholder: false,
-        preview: true,
-        preview_src: nil,
-        mask_closable: false,
-        **html_options
-      )
-        @src = src
-        @alt = alt
-        @width = width
-        @height = height
-        @fallback = fallback
-        @placeholder = placeholder
-        @preview = preview
-        @preview_src = preview_src
-        @mask_closable = mask_closable
-        @html_options = html_options
-        super()
-      end
-
-      attr_reader :src, :alt, :fallback, :preview_src
-
-      def preview_enabled?
-        @preview != false
-      end
-
-      def preview_image_src
-        @preview_src || @src
-      end
-
-      def placeholder?
-        @placeholder == true
-      end
-
-      private
-
-      def wrapper_classes
-        class_names(
-          "image",
-          {
-            placeholder: placeholder?
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def wrapper_attributes
-        attrs = {
-          class: wrapper_classes,
-          data: data_attributes
-        }
-
-        attrs[:style] = size_style if @width || @height
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-
-      def data_attributes
-        {
-          controller: "hakumi--image",
-          hakumi__image_src_value: @src,
-          hakumi__image_preview_src_value: preview_image_src,
-          hakumi__image_alt_value: @alt || "",
-          hakumi__image_fallback_value: @fallback || "",
-          hakumi__image_mask_closable_value: @mask_closable
-        }.merge(@html_options[:data] || {})
-      end
-
-      def img_attributes
-        attrs = {
-          src: @src,
-          alt: @alt,
-          class: "hakumi-image-img",
-          data: {
-            hakumi__image_target: "img",
-            action: "error->hakumi--image#handleError load->hakumi--image#handleLoad"
-          }
-        }
-
-        if preview_enabled?
-          attrs[:data][:action] += " click->hakumi--image#openPreview"
-        end
-
-        attrs[:width] = @width if @width
-        attrs[:height] = @height if @height
-
-        attrs
-      end
-
-      def size_style
-        styles = []
-        styles << "width: #{normalize_size(@width)}" if @width
-        styles << "height: #{normalize_size(@height)}" if @height
-        styles.join("; ")
-      end
-
-      def normalize_size(size)
-        size.is_a?(Integer) ? "#{size}px" : size
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Image
-    module PreviewGroup
-      class Component < Hakumi::BaseComponent
-        renders_many :images, ->(**kwargs) { Hakumi::Image::Component.new(**kwargs, preview: false) }
-
-        def initialize(
-          items: nil,
-          preview: true,
-          **html_options
-        )
-          @items = items
-          @preview = preview
-          @html_options = html_options
-          super()
-        end
-
-        attr_reader :items
-
-        def preview_enabled?
-          @preview != false
-        end
-
-        # Collect image sources from items or rendered images
-        def preview_items
-          if @items.present?
-            @items.map { |item| item.is_a?(Hash) ? item : { src: item } }
-          else
-            images.map do |image|
-              {
-                src: image.preview_src || image.src,
-                alt: image.alt
-              }
-            end
-          end
-        end
-
-        private
-
-        def wrapper_classes
-          class_names(
-            "image-preview-group",
-            {},
-            [ @html_options[:class] ]
-          )
-        end
-
-        def wrapper_attributes
-          attrs = {
-            class: wrapper_classes,
-            data: data_attributes
-          }
-
-          merge_attributes(attrs, @html_options.except(:class))
-        end
-
-        def data_attributes
-          return {} unless preview_enabled?
-
-          {
-            controller: "hakumi--image",
-            hakumi__image_items_value: preview_items.to_json
-          }.merge(@html_options[:data] || {})
-        end
-      end
-    end
-  end
-end

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

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Input
-    # Hakumi Input component
-    # A basic widget for getting user input, supporting text, number, email, etc.
-    #
-    # @example Basic usage
-    #   <%= render Hakumi::Input::Component.new(name: "email", placeholder: "Enter email") %>
-    #
-    # @example With label and caption
-    #   <%= render Hakumi::Input::Component.new(
-    #     name: "username",
-    #     label: "Username",
-    #     caption: "Choose a unique username",
-    #     required: true
-    #   ) %>
-    #
-    # @example With prefix and suffix
-    #   <%= render Hakumi::Input::Component.new(
-    #     name: "amount",
-    #     prefix: "dollar",
-    #     suffix: "USD",
-    #     placeholder: "0.00"
-    #   ) %>
-    class Component < Hakumi::BaseComponent
-      include Hakumi::Concerns::FormField
-
-      SIZES = [ :small, :middle, :large ].freeze
-
-      def initialize(
-        name:,
-        label: nil,
-        caption: nil,
-        value: nil,
-        placeholder: nil,
-        type: :text,
-        size: :middle,
-        disabled: false,
-        readonly: false,
-        required: false,
-        prefix: nil,
-        suffix: nil,
-        prefix_icon: nil,
-        suffix_icon: nil,
-        allow_clear: false,
-        maxlength: nil,
-        standalone: true,
-        rules: nil,
-        errors: [],
-        **html_options
-      )
-        @name = name
-        @label = label
-        @caption = caption
-        @value = value
-        @placeholder = placeholder
-        @type = type
-        @size = size
-        @disabled = disabled
-        @readonly = readonly
-        @required = required
-        @prefix = prefix
-        @suffix = suffix
-        @prefix_icon = prefix_icon
-        @suffix_icon = suffix_icon
-        @allow_clear = allow_clear
-        @maxlength = maxlength
-        @standalone = standalone
-        @rules = rules
-        @errors = Array(errors)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-      end
-
-      def has_affix?
-        @prefix.present? || @suffix.present? || @prefix_icon.present? || @suffix_icon.present? || @allow_clear
-      end
-
-      def wrapper_classes
-        class_names(
-          "input-affix-wrapper",
-          {
-            @size => (@size != :middle),
-            "disabled": @disabled
-          },
-          [ @html_options[:wrapper_class] ]
-        )
-      end
-
-      def input_classes
-        class_names(
-          "input",
-          {
-            @size => (@size != :middle)
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def input_attributes
-        attrs = {
-          type: @type,
-          name: @name,
-          id: input_id,
-          value: @value,
-          placeholder: @placeholder,
-          class: has_affix? ? nil : input_classes,
-          disabled: @disabled ? true : nil,
-          readonly: @readonly ? true : nil,
-          "aria-invalid": has_error? ? "true" : nil,
-          "aria-describedby": describedby_ids,
-          data: { action: "input->hakumi--input#handleInput" }
-        }.compact
-
-        # Merge data attributes
-        if @html_options[:data]
-          attrs[:data] = attrs[:data].merge(@html_options[:data])
-        end
-
-        attrs
-      end
-
-      def wrapper_attributes
-        {
-          class: wrapper_classes,
-          data: {
-            controller: "hakumi--input",
-            hakumi__input_has_clear_value: @allow_clear ? "true" : "false"
-          }
-        }
-      end
-
-      def prefix_element
-        return nil unless @prefix || @prefix_icon
-
-        content_tag(:span, class: "hakumi-input-prefix") do
-          if @prefix_icon
-            render Hakumi::Icon::Component.new(name: @prefix_icon)
-          elsif @prefix
-            @prefix
-          end
-        end
-      end
-
-      def suffix_element
-        return nil unless @suffix || @suffix_icon || @allow_clear
-
-        content_tag(:span, class: "hakumi-input-suffix") do
-          safe_join([ suffix_content, clear_button ].compact)
-        end
-      end
-
-      def suffix_content
-        return nil unless @suffix || @suffix_icon
-
-        if @suffix_icon
-          render Hakumi::Icon::Component.new(name: @suffix_icon)
-        elsif @suffix
-          @suffix
-        end
-      end
-
-      def clear_button
-        return nil unless @allow_clear
-
-        content_tag(:span,
-          class: "hakumi-input-clear-icon hakumi-input-clear-icon-hidden",
-          role: "button",
-          tabindex: "-1",
-          data: { action: "click->hakumi--input#clear" }
-        ) do
-          render Hakumi::Icon::Component.new(name: :close_circle, theme: :filled)
-        end
-      end
-    end
-  end
-end