hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,109 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Space
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Direction = T.type_alias { T.any(Symbol, String) }
+      Size = T.type_alias { T.any(Symbol, Integer) }
+
+      DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      ALIGNMENTS = T.let(%i[start center end baseline].freeze, T::Array[Symbol])
+
+      renders_many :items, "ItemComponent"
+
+      sig do
+        params(
+          direction: Direction,
+          size: Size,
+          align: T.nilable(T.any(Symbol, String)),
+          wrap: T::Boolean,
+          block: T::Boolean,
+          split: HakumiComponents::Types::Renderable,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(direction: :horizontal, size: :small, align: nil, wrap: false, block: false, split: nil, **html_options)
+        @direction = T.let(direction.to_sym, Symbol)
+        @size = T.let(size, Size)
+        @align = T.let(align&.to_sym, T.nilable(Symbol))
+        @wrap = T.let(wrap, T::Boolean)
+        @block = T.let(block, T::Boolean)
+        @split = T.let(split, HakumiComponents::Types::Renderable)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      attr_reader :split
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:direction, DIRECTIONS)
+        validate_inclusion!(:align, ALIGNMENTS) if @align
+        validate_size!
+      end
+
+      sig { void }
+      def validate_size!
+        return if @size.is_a?(Integer)
+        return if SIZES.include?(@size)
+
+        raise ArgumentError, "size must be one of #{SIZES.inspect} or an Integer, got #{@size.inspect}"
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        class_names(
+          "space",
+          {
+            @direction => true,
+            "align-#{@align}": @align.present?,
+            wrap: @wrap,
+            block: @block
+          },
+          html_classes(@html_options)
+        )
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes(
+          { class: wrapper_classes, style: inline_styles },
+          @html_options.except(:class, :style)
+        )
+      end
+
+      sig { returns(String) }
+      def inline_styles
+        gap_size = case @size
+        when :small then "8px"
+        when :default then "16px"
+        when :large then "24px"
+        when Integer then "#{@size}px"
+        else "8px"
+        end
+
+        styles = T.let([ "gap: #{gap_size}" ], T::Array[String])
+        custom_style = html_style(@html_options)
+        styles << custom_style if custom_style
+
+        build_inline_style(styles) || "gap: #{gap_size}"
+      end
+
+      class ItemComponent < ViewComponent::Base
+        extend T::Sig
+
+        sig { returns(ActiveSupport::SafeBuffer) }
+        def call
+          content_tag(:div, content, class: "hakumi-space-item")
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/spin/component.rb

@@ -0,0 +1,270 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Spin
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      DelayInput = T.type_alias { BaseComponent::DimensionInput }
+      ProgressPercent = T.type_alias { T.nilable(T.any(Numeric, Symbol)) }
+      PercentInput = T.type_alias { T.nilable(T.any(Numeric, Symbol, String)) }
+      TipContent = T.type_alias { T.nilable(Types::Renderable) }
+      ControllerLocalValue = T.type_alias { Types::HtmlPrimitive }
+
+      sig do
+        params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue])
+      end
+      def self.extract_controller_locals(params)
+        spinning_value = html_param(params, :spinning)
+
+        {
+          spinning: spinning_value.nil? ? true : boolean_html_param(spinning_value) != false,
+          size: symbol_html_param(html_param(params, :size)),
+          tip: string_html_param(html_param(params, :tip)),
+          delay: parse_delay(html_param(params, :delay)),
+          fullscreen: boolean_html_param(html_param(params, :fullscreen)) == true,
+          percent: parse_percent(html_param(params, :percent))
+        }
+      end
+
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
+      def self.parse_delay(value)
+        return nil if value.nil?
+        return value if value.is_a?(Integer)
+        return value.to_i if value.is_a?(Float)
+
+        value.to_s.strip.presence&.to_i
+      end
+
+      sig { params(value: Types::HtmlAttributeValue).returns(ProgressPercent) }
+      def self.parse_percent(value)
+        return nil if value.nil?
+
+        string_value = value.to_s.strip
+        return :auto if string_value == "auto"
+
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float)
+
+        string_value.presence&.to_f
+      end
+
+      sig do
+        params(
+          spinning: T::Boolean,
+          size: T.nilable(Symbol),
+          tip: TipContent,
+          delay: DelayInput,
+          indicator: TipContent,
+          fullscreen: T::Boolean,
+          percent: PercentInput,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        spinning: true,
+        size: :default,
+        tip: nil,
+        delay: 0,
+        indicator: nil,
+        fullscreen: false,
+        percent: nil,
+        **html_options
+      )
+        @spinning = T.let(cast_boolean(spinning) == true, T::Boolean)
+        @size = T.let(size.nil? ? :default : size.to_sym, Symbol)
+        @tip = T.let(tip, TipContent)
+        @delay = T.let(normalize_delay(delay), Integer)
+        @indicator = T.let(indicator, TipContent)
+        @fullscreen = T.let(fullscreen, T::Boolean)
+        @percent = T.let(normalize_percent(percent), ProgressPercent)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            role: "status",
+            "aria-live": "polite",
+            "aria-busy": @spinning,
+            data: data_attributes
+          },
+          @html_options
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def nested?
+        content.present? && !@fullscreen
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def indicator_markup
+        return render_value(@indicator) if @indicator.present?
+        return progress_indicator if progress?
+
+        default_indicator
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def tip_markup
+        render_value(@tip)
+      end
+
+      sig { returns(T::Boolean) }
+      def show_text?
+        @tip.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def progress?
+        !@percent.nil?
+      end
+
+      sig { returns(T::Boolean) }
+      def progress_auto?
+        @percent == :auto
+      end
+
+      sig { returns(HakumiComponents::Progress::Component) }
+      def progress_component
+        percent = numeric_percent
+        raise "progress_component requires numeric percent" if percent.nil?
+
+        HakumiComponents::Progress::Component.new(
+          percent: percent,
+          type: :circle,
+          size: progress_size,
+          stroke_width: 6,
+          show_info: true
+        )
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+
+        delay_value = normalized_delay
+        raise ArgumentError, "delay must be a non-negative number" if delay_value.negative?
+
+        return unless progress?
+        return if progress_auto?
+
+        unless @percent.is_a?(Numeric)
+          raise ArgumentError, "percent must be numeric or :auto"
+        end
+
+        @percent = @percent.clamp(0, 100)
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        modifiers = {
+          spinning: spinning_class?,
+          "show-text": show_text?,
+          fullscreen: @fullscreen,
+          standalone: !nested?,
+          progress: progress?,
+          "progress-auto": progress_auto?
+        }
+
+        modifiers[:sm] = true if @size == :small
+        modifiers[:lg] = true if @size == :large
+
+        classes = component_classes("spin", modifiers, @html_options)
+        nested? ? [ classes, "hakumi-spin-nested-loading" ].join(" ") : classes
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def data_attributes
+        data = T.let({
+          controller: "hakumi--spin",
+          "hakumi--spin-spinning-value": @spinning
+        }, Types::DataAttributes)
+
+        delay_value = normalized_delay
+        data["hakumi--spin-delay-value"] = delay_value if delay_value.positive?
+        data["hakumi--spin-percent-value"] = percent_value if percent_value
+
+        data
+      end
+
+      sig { returns(Integer) }
+      def normalized_delay
+        @delay
+      end
+
+      sig { returns(PercentInput) }
+      def percent_value
+        return nil unless progress?
+        return "auto" if progress_auto?
+
+        numeric_percent
+      end
+
+      sig { returns(T::Boolean) }
+      def spinning_class?
+        return false unless @spinning
+
+        normalized_delay <= 0
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def progress_indicator
+        return default_indicator if progress_auto?
+
+        render progress_component
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def default_indicator
+        tag.span(class: "hakumi-spin-dot", "aria-hidden": true) do
+          safe_join(Array.new(4) { tag.span(class: "hakumi-spin-dot-item") })
+        end
+      end
+
+      sig { params(value: PercentInput).returns(ProgressPercent) }
+      def normalize_percent(value)
+        return nil if value.nil?
+        return :auto if value == :auto || value.to_s.strip == "auto"
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float)
+
+        parsed = value.to_s.strip
+        parsed.presence&.to_f
+      end
+
+      sig { params(value: DelayInput).returns(Integer) }
+      def normalize_delay(value)
+        return 0 if value.nil?
+        return value if value.is_a?(Integer)
+        return value.to_i if value.is_a?(Float)
+
+        value.to_s.strip.presence&.to_i || 0
+      end
+
+      sig { returns(T.nilable(Numeric)) }
+      def numeric_percent
+        return nil unless @percent.is_a?(Numeric)
+
+        @percent
+      end
+
+      sig { returns(Integer) }
+      def progress_size
+        case @size
+        when :small then 44
+        when :large then 84
+        else 64
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/splitter/component.html.erb

@@ -0,0 +1,9 @@
+<%= tag.div(**wrapper_attributes) do %>
+  <% if panels.any? %>
+    <% panels.each do |panel| %>
+      <%= panel %>
+    <% end %>
+  <% else %>
+    <%= content %>
+  <% end %>
+<% end %>

data/app/components/hakumi_components/splitter/component.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Splitter
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      LAYOUTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+
+      renders_many :panels, ->(size: nil, min: nil, max: nil, resizable: true, collapsible: false, **options) do
+        T.bind(self, HakumiComponents::Splitter::Component)
+        HakumiComponents::Splitter::Panel::Component.new(
+          size: size,
+          min: min,
+          max: max,
+          resizable: resizable,
+          collapsible: collapsible,
+          layout: layout,
+          **options
+        )
+      end
+
+      sig do
+        params(
+          layout: Symbol,
+          resizable: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(layout: :horizontal, resizable: true, **html_options)
+        @layout = T.let(layout, Symbol)
+        @resizable = T.let(resizable, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        validate_props!
+      end
+
+      private
+
+      sig { returns(Symbol) }
+      attr_reader :layout
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("splitter", { @layout => true }, @html_options)
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        existing_id = @html_options[:id]
+        id_value = existing_id.is_a?(String) ? existing_id : generate_id("hakumi-splitter", length: 6)
+
+        data = T.let({
+          controller: "hakumi--splitter",
+          hakumi__splitter_layout_value: @layout.to_s,
+          hakumi__splitter_resizable_value: @resizable
+        }, Types::DataAttributes)
+
+        merge_attributes(
+          { class: wrapper_classes, id: id_value, data: data },
+          @html_options.except(:class, :id)
+        )
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:layout, LAYOUTS)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/splitter/panel/component.html.erb

@@ -0,0 +1 @@
+<%= content_tag :div, content, wrapper_attributes %>

data/app/components/hakumi_components/splitter/panel/component.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Splitter
+    module Panel
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        SizeInput = T.type_alias { BaseComponent::DimensionInput }
+        CollapsibleInput = T.type_alias { T.any(T::Boolean, Types::HtmlAttributes) }
+        CollapsibleValue = T.type_alias { T.any(T::Boolean, String) }
+
+        sig do
+          params(
+            size: SizeInput,
+            min: SizeInput,
+            max: SizeInput,
+            resizable: T::Boolean,
+            collapsible: CollapsibleInput,
+            layout: Symbol,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(size: nil, min: nil, max: nil, resizable: true, collapsible: false, layout: :horizontal, **html_options)
+          @size = T.let(size, SizeInput)
+          @min = T.let(min, SizeInput)
+          @max = T.let(max, SizeInput)
+          @resizable = T.let(resizable, T::Boolean)
+          @collapsible = T.let(collapsible, CollapsibleInput)
+          @layout = T.let(layout, Symbol)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("splitter-panel", {}, @html_options)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          data = T.let({
+            hakumi__splitter_target: "panel",
+            hakumi__splitter_resizable_value: @resizable,
+            hakumi__splitter_collapsible_value: collapsible_config
+          }, Types::DataAttributes)
+          data[:hakumi__splitter_size_value] = @size.to_s if @size
+          data[:hakumi__splitter_min_value] = @min.to_s if @min
+          data[:hakumi__splitter_max_value] = @max.to_s if @max
+
+          merge_attributes(
+            { class: wrapper_classes, style: inline_styles, data: data },
+            @html_options.except(:class, :style)
+          )
+        end
+
+        sig { returns(T.nilable(String)) }
+        def inline_styles
+          styles = T.let([], T::Array[String])
+          sz = @size
+          if sz
+            size_value = sz.is_a?(String) ? sz : "#{sz}px"
+            styles << "flex: 0 0 #{size_value}"
+            styles << "width: #{size_value}" if horizontal_layout?
+            styles << "height: #{size_value}" if vertical_layout?
+          else
+            styles << "flex: 1"
+          end
+          style_value = html_style(@html_options)
+          styles << style_value if style_value
+
+          styles.join("; ").presence
+        end
+
+        sig { returns(CollapsibleValue) }
+        def collapsible_config
+          c = @collapsible
+          return false unless c
+          return c.to_json if c.is_a?(Hash)
+
+          true
+        end
+
+        sig { returns(T::Boolean) }
+        def horizontal_layout?
+          @layout == :horizontal
+        end
+
+        sig { returns(T::Boolean) }
+        def vertical_layout?
+          @layout == :vertical
+        end
+      end
+    end
+  end
+end