hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,8 +1,27 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Image
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      SizeInput = T.type_alias { BaseComponent::DimensionInput }
+
+      sig do
+        params(
+          src: String,
+          alt: T.nilable(String),
+          width: SizeInput,
+          height: SizeInput,
+          fallback: T.nilable(String),
+          placeholder: T::Boolean,
+          preview: T::Boolean,
+          preview_src: T.nilable(String),
+          mask_closable: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         src:,
         alt: nil,
@@ -15,81 +34,86 @@ module HakumiComponents
         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()
+        @src = T.let(src, String)
+        @alt = T.let(alt, T.nilable(String))
+        @width = T.let(width, SizeInput)
+        @height = T.let(height, SizeInput)
+        @fallback = T.let(fallback, T.nilable(String))
+        @placeholder = T.let(placeholder, T::Boolean)
+        @preview = T.let(preview, T::Boolean)
+        @preview_src = T.let(preview_src, T.nilable(String))
+        @mask_closable = T.let(mask_closable, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
       end
 
-      attr_reader :src, :alt, :fallback, :preview_src
+      sig { returns(String) }
+      attr_reader :src
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :alt, :fallback, :preview_src
 
+      sig { returns(T::Boolean) }
       def preview_enabled?
-        @preview != false
+        @preview
       end
 
+      sig { returns(String) }
       def preview_image_src
         @preview_src || @src
       end
 
+      sig { returns(T::Boolean) }
       def placeholder?
-        @placeholder == true
+        @placeholder
       end
 
       private
 
+      sig { returns(String) }
       def wrapper_classes
-        class_names(
-          "image",
-          {
-            placeholder: placeholder?
-          },
-          [ @html_options[:class] ]
-        )
+        component_classes("image", { placeholder: placeholder? }, @html_options)
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = {
-          class: wrapper_classes,
-          data: data_attributes
-        }
-
+        attrs = T.let({ class: wrapper_classes, data: data_attributes }, Types::HtmlAttributes)
         attrs[:style] = size_style if @width || @height
-
         merge_attributes(attrs, @html_options.except(:class))
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        {
+        data = T.let({
           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] || {})
+        }, Types::DataAttributes)
+
+        extra = @html_options[:data]
+        if extra.is_a?(Hash)
+          extra.each { |k, v| data[k] = v }
+        end
+
+        data
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def img_attributes
-        attrs = {
+        action_str = "error->hakumi--image#handleError load->hakumi--image#handleLoad"
+        action_str += " click->hakumi--image#openPreview" if preview_enabled?
+
+        attrs = T.let({
           src: @src,
           alt: @alt,
           class: "hakumi-image-img",
           data: {
             hakumi__image_target: "img",
-            action: "error->hakumi--image#handleError load->hakumi--image#handleLoad"
+            action: action_str
           }
-        }
-
-        if preview_enabled?
-          attrs[:data][:action] += " click->hakumi--image#openPreview"
-        end
+        }, Types::HtmlAttributes)
 
         attrs[:width] = @width if @width
         attrs[:height] = @height if @height
@@ -97,15 +121,54 @@ module HakumiComponents
         attrs
       end
 
+      sig { returns(String) }
       def size_style
-        styles = []
-        styles << "width: #{normalize_size(@width)}" if @width
-        styles << "height: #{normalize_size(@height)}" if @height
+        styles = T.let([], T::Array[String])
+        w = @width
+        h = @height
+        styles << "width: #{normalize_size(w)}" if w
+        styles << "height: #{normalize_size(h)}" if h
         styles.join("; ")
       end
 
+      sig { params(size: SizeInput).returns(String) }
       def normalize_size(size)
-        size.is_a?(Integer) ? "#{size}px" : size
+        size.is_a?(Numeric) ? "#{size}px" : size.to_s
+      end
+
+      sig { returns(String) }
+      def preview_text
+        t_default(:preview, default: "Preview")
+      end
+
+      sig { returns(String) }
+      def flip_vertical_title
+        t_default(:flip_vertical, default: "Flip Vertical")
+      end
+
+      sig { returns(String) }
+      def flip_horizontal_title
+        t_default(:flip_horizontal, default: "Flip Horizontal")
+      end
+
+      sig { returns(String) }
+      def rotate_left_title
+        t_default(:rotate_left, default: "Rotate Left")
+      end
+
+      sig { returns(String) }
+      def rotate_right_title
+        t_default(:rotate_right, default: "Rotate Right")
+      end
+
+      sig { returns(String) }
+      def zoom_out_title
+        t_default(:zoom_out, default: "Zoom Out")
+      end
+
+      sig { returns(String) }
+      def zoom_in_title
+        t_default(:zoom_in, default: "Zoom In")
       end
     end
   end

data/app/components/hakumi_components/image/preview_group/component.html.erb

@@ -3,7 +3,7 @@
     <% images.each_with_index do |image, index| %>
       <div class="hakumi-image-preview-group-item" 
            data-index="<%= index %>" 
-           data-action="click->hakumi--image-preview-group#openPreview">
+           data-action="click->hakumi--image#openPreview">
         <%= image %>
       </div>
     <% end %>

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

@@ -1,68 +1,73 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Image
     module PreviewGroup
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
         renders_many :images, ->(**kwargs) { HakumiComponents::Image::Component.new(**kwargs, preview: false) }
 
-        def initialize(
-          items: nil,
-          preview: true,
-          **html_options
-        )
-          @items = items
-          @preview = preview
-          @html_options = html_options
-          super()
+        sig do
+          params(
+            items: T.nilable(T::Array[T.any(String, Types::HtmlAttributes, HakumiComponents::Image::PreviewGroup::Item)]),
+            preview: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(items: nil, preview: true, **html_options)
+          @items = T.let(HakumiComponents::Image::PreviewGroup::Item.coerce_all(items), T::Array[HakumiComponents::Image::PreviewGroup::Item])
+          @preview = T.let(preview, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
+        sig { returns(T::Array[HakumiComponents::Image::PreviewGroup::Item]) }
         attr_reader :items
 
+        sig { returns(T::Boolean) }
         def preview_enabled?
-          @preview != false
+          @preview
         end
 
-        # Collect image sources from items or rendered images
+        sig { returns(T::Array[HakumiComponents::Image::PreviewGroup::Item]) }
         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
+          return @items if @items.any?
+
+          images.filter_map { |image| preview_item_from_slot(image) }
         end
 
         private
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names(
-            "image-preview-group",
-            {},
-            [ @html_options[:class] ]
-          )
+          class_names("image-preview-group", {}, html_classes(@html_options))
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
-          attrs = {
-            class: wrapper_classes,
-            data: data_attributes
-          }
-
+          attrs = T.let({ class: wrapper_classes, data: data_attributes }, Types::HtmlAttributes)
           merge_attributes(attrs, @html_options.except(:class))
         end
 
+        sig { returns(Types::DataAttributes) }
         def data_attributes
-          return {} unless preview_enabled?
+          return T.let({}, Types::DataAttributes) unless preview_enabled?
+
+          data = stimulus_attrs("hakumi--image", { items: preview_items.map(&:to_payload) })
+          extra = data_attributes_from(@html_options[:data])
+          return data if extra.empty?
+
+          data.merge(extra)
+        end
+
+        sig { params(image: T.any(HakumiComponents::Image::Component, ViewComponent::Slot)).returns(T.nilable(HakumiComponents::Image::PreviewGroup::Item)) }
+        def preview_item_from_slot(image)
+          raw_src = image.public_send(:preview_src) || image.public_send(:src)
+          return nil unless raw_src.is_a?(String) && raw_src.present?
 
-          {
-            controller: "hakumi--image",
-            hakumi__image_items_value: preview_items.to_json
-          }.merge(@html_options[:data] || {})
+          raw_alt = image.public_send(:alt)
+          HakumiComponents::Image::PreviewGroup::Item.new(src: raw_src, alt: raw_alt.is_a?(String) ? raw_alt : nil)
         end
       end
     end

data/app/components/hakumi_components/image/preview_group/item.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Image
+    module PreviewGroup
+      class Item
+        extend T::Sig
+
+        sig { params(src: String, alt: T.nilable(String)).void }
+        def initialize(src:, alt: nil)
+          @src = T.let(src, String)
+          @alt = T.let(alt, T.nilable(String))
+        end
+
+        sig { returns(String) }
+        attr_reader :src
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :alt
+
+        sig { returns(T::Hash[Symbol, T.nilable(String)]) }
+        def to_payload
+          { src: @src, alt: @alt }
+        end
+
+        sig { params(items: T.nilable(T::Array[T.any(String, Types::HtmlAttributes, HakumiComponents::Image::PreviewGroup::Item)])).returns(T::Array[HakumiComponents::Image::PreviewGroup::Item]) }
+        def self.coerce_all(items)
+          return [] if items.nil?
+
+          items.map { |item| coerce(item) }
+        end
+
+        sig { params(item: T.any(String, Types::HtmlAttributes, HakumiComponents::Image::PreviewGroup::Item)).returns(HakumiComponents::Image::PreviewGroup::Item) }
+        def self.coerce(item)
+          return item if item.is_a?(HakumiComponents::Image::PreviewGroup::Item)
+          return new(src: item) if item.is_a?(String)
+
+          src = item[:src]
+          alt = item[:alt]
+          raise ArgumentError, "preview group item src is required" unless src.is_a?(String) && src.present?
+
+          new(src: src, alt: alt.is_a?(String) ? alt : nil)
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@
   <% end %>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= input_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>