its-showtime 0.1.1

data/lib/showtime/components/inputs.rb

@@ -0,0 +1,390 @@
+require_relative 'base'
+require 'tempfile'
+require 'base64'
+require 'ostruct'
+
+module Showtime
+  module Components
+    class Button < BaseComponent
+      attr_reader :label, :value
+
+      def initialize(label, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        
+        # Initialize button state
+        @value = St.get(@key, false)
+      end
+      
+      def clicked?
+        St.get(@key) == true
+      end
+      
+      def value
+        St.get(@key) == true
+      end
+      
+      def to_h
+        # Get the latest value from the session
+        @value = St.get(@key) == true
+        
+        super.merge({
+          label: @label,
+          value: @value
+        })
+      end
+    end
+    
+    class Checkbox < BaseComponent
+      attr_reader :label, :value
+      
+      def initialize(label, value: false, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @value = value
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          value: @value
+        })
+      end
+    end
+    
+    class TextInput < BaseComponent
+      attr_reader :label
+      
+      def initialize(label, value: "", key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @value = value
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          value: value
+        })
+      end
+    end
+    
+    class NumberInput < BaseComponent
+      attr_reader :label, :min_value, :max_value, :step
+      
+      def initialize(label, min_value: nil, max_value: nil, value: nil, step: 1, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @min_value = min_value
+        @max_value = max_value
+        @value = value || min_value || 0
+        @step = step
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          min_value: @min_value,
+          max_value: @max_value,
+          value: value,
+          step: @step
+        })
+      end
+    end
+    
+    class TextArea < BaseComponent
+      attr_reader :label, :height
+      
+      def initialize(label, value: "", height: nil, key: nil, help: nil, **kwargs)
+        super(key: key, help: help)
+        @label = label
+        # Ensure @value is initialized even if not using session or no initial value in session
+        @value = St.get(@key) || value
+        @height = height
+        @kwargs = kwargs
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          value: value, # Use the new value getter
+          height: @height
+        }).merge(@kwargs)
+      end
+    end
+    
+    class DateInput < BaseComponent
+      attr_reader :label, :value, :min_value, :max_value, :format
+      
+      def initialize(label, value: nil, min_value: nil, max_value: nil, format: 'YYYY-MM-DD', key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @min_value = min_value
+        @max_value = max_value
+        @format = format
+        
+        # Initialize value in session
+        initial_value = value || Date.today
+        St.set(@key, initial_value) if St.get(@key).nil?
+      end
+      
+      def value
+        stored_value = St.get(@key)
+        return Date.today if stored_value.nil?
+        
+        # Convert ISO8601 string back to Date if needed
+        stored_value.is_a?(String) ? Date.parse(stored_value) : stored_value
+      end
+      
+      def to_h
+        current_value = value
+        super.merge({
+          label: @label,
+          value: current_value.is_a?(Date) ? current_value.iso8601 : current_value,
+          min_value: @min_value&.is_a?(Date) ? @min_value.iso8601 : @min_value,
+          max_value: @max_value&.is_a?(Date) ? @max_value.iso8601 : @max_value,
+          format: @format
+        })
+      end
+    end
+    
+    class FileUploader < BaseComponent
+      attr_reader :label, :type, :accept_multiple_files, :max_size, :wide
+
+      DEFAULT_MAX_SIZE = 200 * 1024 * 1024 # 200 MB
+
+      def initialize(label, type: nil, accept_multiple_files: false, max_size: DEFAULT_MAX_SIZE, key: nil, help: nil, wide: false)
+        super(key: key, help: help)
+        @label = label
+        @type = type
+        @accept_multiple_files = accept_multiple_files
+        @max_size = max_size
+        @key ||= "file_uploader_#{label.downcase.gsub(/\W+/, '_')}"
+        @wide = wide
+      end
+
+      def value
+        file_data = St.get(@key)
+        return nil if file_data.nil?
+
+        size = file_data['size']
+        name = file_data['name']
+        content_type = file_data['type']
+        file_path = file_data['path']
+
+        return nil if size > @max_size
+
+        # Create a file struct that reads from the server-side file path
+        OpenStruct.new(
+          name: name,
+          size: size,
+          content_type: content_type,
+          path: file_path,
+          read: -> { 
+            # Read the file directly from the server's filesystem
+            # The path is now a real file path on the server
+            File.binread(file_path)
+          },
+          temp_path: file_path
+        )
+      end
+      
+      def self.finalizer(path)
+        proc { File.delete(path) if File.exist?(path) }
+      end
+
+      # Convenience method to read content regardless of storage type
+      def read
+        uploaded_file = value
+        uploaded_file&.read&.call # Call the read lambda on the OpenStruct
+      end
+
+      # Convenience method to read content as a Base64 encoded string
+      # Accepts the result of self.value as an argument to avoid re-fetching from session
+      def read_as_base64(uploaded_file_details = nil)
+        # If no details passed, try to get them via self.value (maintaining old behavior if called directly)
+        # However, the preferred way will be to pass the result of self.value
+        current_uploaded_file = uploaded_file_details || value
+        return nil unless current_uploaded_file && current_uploaded_file.path && current_uploaded_file.content_type
+
+        # Ensure the temporary file exists before trying to read it
+        return nil unless File.exist?(current_uploaded_file.path)
+
+        binary_data = File.binread(current_uploaded_file.path)
+        "data:#{current_uploaded_file.content_type};base64,#{Base64.strict_encode64(binary_data)}"
+      end
+      
+      def to_h
+        mime_types = if @type.is_a?(Array)
+          @type
+        elsif @type.is_a?(String)
+          [@type]
+        elsif @type.nil?
+          []
+        end
+        
+        super.merge({
+          label: @label,
+          accept: mime_types,
+          multiple: @accept_multiple_files,
+          max_size: @max_size,
+          value: St.get(@key),
+          wide: @wide
+        })
+      end
+    end
+    
+    class Select < BaseComponent
+      attr_reader :label, :options
+      
+      def initialize(label, options, value: nil, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @options = map_options(options)
+        # Store initial value in session if key is provided and no value exists
+        if @key && St.get(@key).nil?
+          St.set(@key, value)
+        end
+        # Ensure @value is initialized even if not using session or no initial value in session
+        @value = St.get(@key) || value
+      end
+
+      def value
+        # Retrieve value from session if key is provided
+        @key ? St.get(@key) : @value
+      end
+
+      def map_options(options)
+        # Convert options to a hash format if they are not already
+        # This assumes options are either strings or hashes
+        if !options.is_a?(Array)
+          @errors << "Options must be an array"
+        end
+        options.map do |option|
+          if option.is_a?(Hash)
+            option.transform_keys(&:to_s)
+          else
+            { value: option, label: option }
+          end
+        end
+        
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          options: @options,
+          value: value
+        })
+      end
+    end
+    
+    class Multiselect < BaseComponent
+      attr_reader :label, :options, :value
+      
+      def initialize(label, options, default: [], key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @options = options
+        @value = default & options # Intersection to ensure only valid options
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          options: @options,
+          value: @value
+        })
+      end
+    end
+    
+    class Slider < BaseComponent
+      attr_reader :label, :min_value, :max_value, :value, :step
+      
+      def initialize(label, min_value: 0, max_value: 100, value: nil, step: 1, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @min_value = min_value
+        @max_value = max_value
+        @value = value || min_value
+        @step = step
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          min_value: @min_value,
+          max_value: @max_value,
+          value: @value,
+          step: @step
+        })
+      end
+    end
+    
+    class Radio < BaseComponent
+      attr_reader :label, :options, :index, :value
+      
+      def initialize(label, options, index: 0, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @options = options
+        @index = [index, options.length - 1].min
+        @value = options[@index] if options.any?
+      end
+      
+      def to_h
+        super.merge({
+          label: @label,
+          options: @options,
+          value: @value
+        })
+      end
+    end
+  end
+
+  module St
+    def self.button(label, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Button.new(label, key: key, help: help))
+    end
+    
+    def self.checkbox(label, value: false, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Checkbox.new(label, value: value, key: key, help: help))
+    end
+    
+    def self.text_input(label, value: "", key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::TextInput.new(label, value: value, key: key, help: help))
+    end
+    
+    def self.number_input(label, min_value: nil, max_value: nil, value: nil, step: 1, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::NumberInput.new(label, min_value: min_value, max_value: max_value, value: value, step: step, key: key, help: help))
+    end
+    
+    def self.text_area(label, value: "", height: nil, key: nil, help: nil, **kwargs)
+      Showtime::session.add_element(Showtime::Components::TextArea.new(label, value: value, height: height, key: key, help: help, **kwargs))
+    end
+    
+    def self.date_input(label, value: nil, min_value: nil, max_value: nil, format: 'YYYY-MM-DD', key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::DateInput.new(label, value: value, min_value: min_value, max_value: max_value, format: format, key: key, help: help))
+    end
+    
+    def self.file_uploader(label, type: nil, accept_multiple_files: false, max_size: Showtime::Components::FileUploader::DEFAULT_MAX_SIZE, key: nil, help: nil, wide: false)
+      Showtime::session.add_element(Showtime::Components::FileUploader.new(label, type: type, accept_multiple_files: accept_multiple_files, max_size: max_size, key: key, help: help, wide: wide))
+    end
+    
+    def self.select(label, options, value: nil, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Select.new(label, options, value: value, key: key, help: help))
+    end
+    
+    def self.multiselect(label, options, default: [], key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Multiselect.new(label, options, default: default, key: key, help: help))
+    end
+    
+    def self.slider(label, min_value: 0, max_value: 100, value: nil, step: 1, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Slider.new(label, min_value: min_value, max_value: max_value, value: value, step: step, key: key, help: help))
+    end
+    
+    def self.radio(label, options, index: 0, key: nil, help: nil)
+      Showtime::session.add_element(Showtime::Components::Radio.new(label, options, index: index, key: key, help: help))
+    end
+  end
+end

data/lib/showtime/components/layout.rb

@@ -0,0 +1,135 @@
+require_relative 'base'
+
+module Showtime
+  module Components
+    class ContainerComponent < BaseComponent
+      attr_reader :children
+
+      def initialize(key: nil, help: nil)
+        super(key: key, help: help)
+        @children = []
+      end
+
+      def to_h
+        super.merge({
+          children: @children.map(&:to_h)
+        })
+      end
+    end
+
+    class Container < ContainerComponent
+      attr_reader :title, :border, :grow
+
+      def initialize(title: nil, border: true, grow: false, key: nil, help: nil)
+        super(key: key, help: help)
+        @title = title
+        @border = border
+        @grow = grow
+      end
+
+      def to_h
+        super.merge({
+          title: @title,
+          border: @border,
+          grow: @grow
+        })
+      end
+    end
+
+    class SplitLayout < ContainerComponent
+      attr_reader :direction, :sizes, :height
+
+      def initialize(direction: 'horizontal', sizes: nil, height: nil, ttype: 'card', key: nil, help: nil)
+        super(key: key, help: help)
+        @direction = direction
+        @sizes = sizes
+        @height = height
+        @ttype = ttype
+      end
+
+      def to_h
+        super.merge({
+          direction: @direction,
+          sizes: @sizes,
+          height: @height,
+          ttype: @ttype
+        })
+      end
+    end
+
+    class Collapse < ContainerComponent
+      attr_reader :label, :expanded
+
+      def initialize(label, expanded: false, key: nil, help: nil)
+        super(key: key, help: help)
+        @label = label
+        @expanded = expanded
+        St.set(@key, expanded) if St.get(@key).nil?
+      end
+
+      def value
+        St.get(@key)
+      end
+
+      def to_h
+        super.merge({
+          label: @label,
+          expanded: value
+        })
+      end
+    end
+  end
+
+  module St
+    def self.container(title: nil, border: true, grow: false, key: nil, help: nil, &block)
+      container = Showtime::Components::Container.new(title: title, border: border, grow: grow, key: key, help: help)
+      element = Showtime::session.add_element(container)
+
+      if block_given?
+        Showtime::session.with_container(container) do
+          yield
+        end
+      end
+
+      element
+    end
+
+    # Build a responsive split layout container.
+    #
+    # @param direction [String]
+    #   'horizontal' (default) or 'vertical'
+    # @param sizes [Array<Integer>, nil]
+    #   column sizes for each child. When provided in horizontal mode,
+    #   they are interpreted on a 24-column grid (Ant Design) and should sum to 24
+    #   so sibling panels align; when omitted, equal distribution across 24 columns is used.
+    # @param height [Integer, String, nil] optional height for vertical layouts (number => px, string => CSS value)
+    # @param type [String] visual style for the container (card/ghost/success/info/warning/error)
+    # @param key [String, nil] component key
+    # @param help [String, nil] optional tooltip/help text
+    def self.split_layout(direction: 'horizontal', sizes: nil, height: nil, type: 'card', key: nil, help: nil, &block)
+      container = Showtime::Components::SplitLayout.new(direction: direction, sizes: sizes, height: height, ttype: type, key: key, help: help)
+      element = Showtime::session.add_element(container)
+
+      if block_given?
+        Showtime::session.with_container(container) do
+          yield
+        end
+      end
+
+      element
+    end
+
+    def self.collapse(label, expanded: false, key: nil, help: nil, &block)
+      container = Showtime::Components::Collapse.new(label, expanded: expanded, key: key, help: help)
+      element = Showtime::session.add_element(container)
+
+      if block_given?
+        Showtime::session.with_container(container) do
+          yield
+        end
+      end
+
+      element
+    end
+  end
+end

data/lib/showtime/components/media.rb

@@ -0,0 +1,73 @@
+require 'pathname'
+require 'base64'
+require_relative 'base'
+require_relative '../helpers'
+
+module Showtime
+  module Components
+    class Image < BaseComponent
+      attr_reader :src, :caption, :width, :use_column_width
+      
+      def initialize(src, caption: nil, width: nil, use_column_width: true, key: nil, help: nil)
+        super(key: key, help: help)
+        @src = resolve_src(src)
+        @caption = caption
+        @width = width
+        @use_column_width = use_column_width
+      end
+
+      def resolve_src(src)
+        # Only process if it's a string, not a URL, not a data URI, and not already absolute
+        if src.is_a?(String) &&
+           !src.start_with?('http://', 'https://') &&
+           !src.include?(';base64,') &&
+           !(defined?(Pathname) && Pathname.new(src).absolute?) # Check Pathname.new(src).absolute? only if Pathname is defined
+          # The '1' offset is because St.image calls Image.new, which then calls resolve_src.
+          # We want the path relative to the script calling St.image.
+          return Showtime::Helpers.absolute_path(src) 
+        end
+        src # Return original src if it's a URL, data URI, absolute, or not a string
+      end
+      
+      def to_h
+        Showtime::Logger.debug("Image src: #{@src}")
+        image_data = if @src.is_a?(String) && File.exist?(@src)
+          # It's a file path
+          mime_type = case File.extname(@src).downcase
+                      when '.png' then 'image/png'
+                      when '.jpg', '.jpeg' then 'image/jpeg'
+                      when '.gif' then 'image/gif'
+                      when '.svg' then 'image/svg+xml'
+                      else 'application/octet-stream'
+                      end
+          "data:#{mime_type};base64,#{Base64.strict_encode64(File.read(@src))}"
+        elsif @src.is_a?(String) && @src.start_with?('http')
+          # It's a URL
+          @src
+        elsif @src.is_a?(String) && @src.include?(';base64,')
+          # It's already a data URI
+          @src
+        else
+          # Assume it's binary data (or needs default handling if not a recognized string type)
+          # This branch might need further refinement if @src can be non-string binary
+          Showtime::Logger.warn("Image src is not a file path, URL, or data URI. Attempting to treat as binary. Src: #{@src.class}")
+          "data:image/png;base64,#{Base64.strict_encode64(@src.to_s)}" # Ensure @src is stringified if it's raw binary
+        end
+        
+        super.merge({
+          src: image_data,
+          caption: @caption,
+          width: @width,
+          use_column_width: @use_column_width
+        })
+      end
+    end
+  end
+
+  module St
+    def self.image(src, caption: nil, width: nil, use_column_width: false, key: nil, help: nil)
+      component = Components::Image.new(src, caption: caption, width: width, use_column_width: use_column_width, key: key, help: help)
+      Showtime.session.add_element(component)
+    end
+  end
+end