lightning_ui_kit 0.3.4 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/collection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "action_view/renderer/collection_renderer"
+
+module ViewComponent
+  class Collection
+    include Enumerable
+
+    attr_reader :component
+
+    delegate :size, to: :@collection
+
+    def render_in(view_context, &block)
+      components.map do |component|
+        component.render_in(view_context, &block)
+      end.join(rendered_spacer(view_context)).html_safe
+    end
+
+    def each(&block)
+      components.each(&block)
+    end
+
+    if defined?(Rails::VERSION) && Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR == 1
+      # Rails expects us to define `format` on all renderables,
+      # but we do not know the `format` of a ViewComponent until runtime.
+      def format
+        nil
+      end
+    end
+
+    private
+
+    def components
+      return @components if defined? @components
+
+      iterator = ActionView::PartialIteration.new(@collection.size)
+
+      component.__vc_validate_collection_parameter!(validate_default: true)
+
+      @components = @collection.map do |item|
+        component.new(**component_options(item, iterator)).tap do |component|
+          iterator.iterate!
+        end
+      end
+    end
+
+    def initialize(component, object, spacer_component, **options)
+      @component = component
+      @collection = collection_variable(object || [])
+      @spacer_component = spacer_component
+      @options = options
+    end
+
+    def collection_variable(object)
+      if object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        raise InvalidCollectionArgumentError
+      end
+    end
+
+    def component_options(item, iterator)
+      item_options = {component.__vc_collection_parameter => item}
+      item_options[component.__vc_collection_counter_parameter] = iterator.index if component.__vc_counter_argument_present?
+      item_options[component.__vc_collection_iteration_parameter] = iterator.dup if component.__vc_iteration_argument_present?
+
+      @options.merge(item_options)
+    end
+
+    def rendered_spacer(view_context)
+      if @spacer_component
+        @spacer_component.render_in(view_context)
+      else
+        ""
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/compiler.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module ViewComponent
+  class Compiler
+    # Compiler development mode. Can be either:
+    # * true (a blocking mode which ensures thread safety when redefining the `call` method for components,
+    #                default in Rails development and test mode)
+    # * false(a non-blocking mode, default in Rails production mode)
+    class_attribute :__vc_development_mode, default: false
+
+    def initialize(component)
+      @component = component
+      @lock = Mutex.new
+    end
+
+    def compiled?
+      CompileCache.compiled?(@component)
+    end
+
+    def compile(raise_errors: false, force: false)
+      return if compiled? && !force
+      return if @component == ViewComponent::Base
+
+      @lock.synchronize do
+        # this check is duplicated so that concurrent compile calls can still
+        # early exit
+        return if compiled? && !force
+
+        gather_templates
+
+        if self.class.__vc_development_mode && @templates.any?(&:requires_compiled_superclass?)
+          @component.superclass.__vc_compile(raise_errors: raise_errors)
+        end
+
+        if template_errors.present?
+          raise TemplateError.new(template_errors) if raise_errors
+
+          # this return is load bearing, and prevents the component from being considered "compiled?"
+          return false
+        end
+
+        if raise_errors
+          @component.__vc_validate_initialization_parameters!
+          @component.__vc_validate_collection_parameter!
+        end
+
+        define_render_template_for
+
+        @component.__vc_register_default_slots
+        @component.__vc_build_i18n_backend
+
+        CompileCache.register(@component)
+
+        @component.after_compile
+      end
+    end
+
+    # @return all matching compiled templates, in priority order based on the requested details from LookupContext
+    #
+    # @param [ActionView::TemplateDetails::Requested] requested_details i.e. locales, formats, variants
+    def find_templates_for(requested_details)
+      filtered_templates = @templates.select do |template|
+        template.details.matches?(requested_details)
+      end
+
+      if filtered_templates.count > 1
+        filtered_templates.sort_by! do |template|
+          template.details.sort_key_for(requested_details)
+        end
+      end
+
+      filtered_templates
+    end
+
+    private
+
+    attr_reader :templates
+
+    def define_render_template_for
+      @templates.each do |template|
+        template.compile_to_component
+      end
+
+      @component.silence_redefinition_of_method(:render_template_for)
+
+      if @templates.one?
+        template = @templates.first
+        safe_call = template.safe_method_name_call
+        @component.define_method(:render_template_for) do |_|
+          @current_template = template
+          instance_exec(&safe_call)
+        end
+      else
+        compiler = self
+        @component.define_method(:render_template_for) do |details|
+          if (@current_template = compiler.find_templates_for(details).first)
+            instance_exec(&@current_template.safe_method_name_call)
+          else
+            raise MissingTemplateError.new(self.class.name, details)
+          end
+        end
+      end
+    end
+
+    def template_errors
+      @_template_errors ||= begin
+        errors = []
+
+        errors << "Couldn't find a template file or inline render method for #{@component}." if @templates.empty?
+
+        @templates
+          .map { |template| [template.variant, template.format] }
+          .tally
+          .select { |_, count| count > 1 }
+          .each do |tally|
+            variant, this_format = tally.first
+
+            variant_string = " for variant `#{variant}`" if variant.present?
+
+            errors << "More than one #{this_format.upcase} template found#{variant_string} for #{@component}. "
+        end
+
+        default_template_types = @templates.each_with_object(Set.new) do |template, memo|
+          next if template.variant
+
+          memo << :template_file if !template.inline_call?
+          memo << :inline_render if template.inline_call? && template.defined_on_self?
+
+          memo
+        end
+
+        if default_template_types.length > 1
+          errors <<
+            "Template file and inline render method found for #{@component}. " \
+            "There can only be a template file or inline render method per component."
+        end
+
+        # If a template has inline calls, they can conflict with template files the component may use
+        # to render. This attempts to catch and raise that issue before run time. For example,
+        # `def render_mobile` would conflict with a sidecar template of `component.html+mobile.erb`
+        duplicate_template_file_and_inline_call_variants =
+          @templates.reject(&:inline_call?).map(&:variant) &
+          @templates.select { _1.inline_call? && _1.defined_on_self? }.map(&:variant)
+
+        unless duplicate_template_file_and_inline_call_variants.empty?
+          count = duplicate_template_file_and_inline_call_variants.count
+
+          errors <<
+            "Template #{"file".pluralize(count)} and inline render #{"method".pluralize(count)} " \
+            "found for #{"variant".pluralize(count)} " \
+            "#{duplicate_template_file_and_inline_call_variants.map { |v| "'#{v}'" }.to_sentence} " \
+            "in #{@component}. There can only be a template file or inline render method per variant."
+        end
+
+        @templates.select(&:variant).each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |template, memo|
+          memo[template.normalized_variant_name] << template.variant
+          memo
+        end.each do |_, variant_names|
+          next unless variant_names.length > 1
+
+          errors << "Colliding templates #{variant_names.sort.map { |v| "'#{v}'" }.to_sentence} found in #{@component}."
+        end
+
+        errors
+      end
+    end
+
+    def gather_templates
+      @templates ||=
+        if @component.__vc_inline_template.present?
+          [Template::Inline.new(
+            component: @component,
+            inline_template: @component.__vc_inline_template
+          )]
+        else
+          path_parser = ActionView::Resolver::PathParser.new
+          templates = @component.sidecar_files(
+            ActionView::Template.template_handler_extensions
+          ).map do |path|
+            details = path_parser.parse(path).details
+            Template::File.new(component: @component, path: path, details: details)
+          end
+
+          component_instance_methods_on_self = @component.instance_methods(false)
+
+          (
+            @component.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } - @component.included_modules
+          ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
+            .uniq
+            .each do |method_name|
+              templates << Template::InlineCall.new(
+                component: @component,
+                method_name: method_name,
+                defined_on_self: component_instance_methods_on_self.include?(method_name)
+              )
+          end
+
+          templates
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/config.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "view_component/deprecation"
+
+module ViewComponent
+  class Config
+    class << self
+      # `new` without any arguments initializes the default configuration, but
+      # it's important to differentiate in case that's no longer the case in
+      # future.
+      alias_method :default, :new
+
+      def defaults
+        ActiveSupport::OrderedOptions.new.merge!({
+          generate: default_generate_options,
+          previews: default_previews_options,
+          instrumentation_enabled: false
+        })
+      end
+
+      # @!attribute generate
+      # @return [ActiveSupport::OrderedOptions]
+      # The subset of configuration options relating to generators.
+      #
+      # All options under this namespace default to `false` unless otherwise
+      # stated.
+      #
+      # #### `#path`
+      #
+      # Where to put generated components. Defaults to `app/components`:
+      #
+      #     config.view_component.generate.path = "lib/components"
+      #
+      # #### `#sidecar`
+      #
+      # Always generate a component with a sidecar directory:
+      #
+      #     config.view_component.generate.sidecar = true
+      #
+      # #### `#stimulus_controller`
+      #
+      # Always generate a Stimulus controller alongside the component:
+      #
+      #     config.view_component.generate.stimulus_controller = true
+      #
+      # #### `#typescript`
+      #
+      # Generate TypeScript files instead of JavaScript files:
+      #
+      #     config.view_component.generate.typescript = true
+      #
+      # #### `#locale`
+      #
+      # Always generate translations file alongside the component:
+      #
+      #     config.view_component.generate.locale = true
+      #
+      # #### `#distinct_locale_files`
+      #
+      # Always generate as many translations files as available locales:
+      #
+      #     config.view_component.generate.distinct_locale_files = true
+      #
+      # One file will be generated for each configured `I18n.available_locales`,
+      # falling back to `[:en]` when no `available_locales` is defined.
+      #
+      # #### `#preview`
+      #
+      # Always generate a preview alongside the component:
+      #
+      #      config.view_component.generate.preview = true
+      #
+      # #### #preview_path
+      #
+      # Path to generate preview:
+      #
+      #      config.view_component.generate.preview_path = "test/components/previews"
+      #
+      # Required when there is more than one path defined in preview_paths.
+      # Defaults to `""`. If this is blank, the generator will use
+      # `ViewComponent.config.previews.paths` if defined,
+      # `"test/components/previews"` otherwise
+      #
+      # #### `#use_component_path_for_rspec_tests`
+      #
+      # Whether to use `config.generate.path` when generating new
+      # RSpec component tests:
+      #
+      #     config.view_component.generate.use_component_path_for_rspec_tests = true
+      #
+      # When set to `true`, the generator will use the `path` to
+      # decide where to generate the new RSpec component test.
+      # For example, if the `path` is
+      # `app/views/components`, then the generator will create a new spec file
+      # in `spec/views/components/` rather than the default `spec/components/`.
+
+      # @!attribute previews
+      # @return [ActiveSupport::OrderedOptions]
+      # The subset of configuration options relating to previews.
+      #
+      # #### `#controller`
+      #
+      # The controller used for previewing components. Defaults to `ViewComponentsController`:
+      #
+      #     config.view_component.previews.controller = "MyPreviewController"
+      #
+      # #### `#route`
+      #
+      # The entry route for component previews. Defaults to `/rails/view_components`:
+      #
+      #     config.view_component.previews.route = "/my_previews"
+      #
+      # #### `#enabled`
+      #
+      # Whether component previews are enabled. Defaults to `true` in development and test environments:
+      #
+      #     config.view_component.previews.enabled = false
+      #
+      # #### `#default_layout`
+      #
+      # A custom default layout used for the previews index page and individual previews. Defaults to `nil`:
+      #
+      #     config.view_component.previews.default_layout = "preview_layout"
+      #
+
+      # @!attribute instrumentation_enabled
+      # @return [Boolean]
+      # Whether ActiveSupport notifications are enabled.
+      # Defaults to `false`.
+
+      def default_preview_paths
+        (default_rails_preview_paths + default_rails_engines_preview_paths).uniq
+      end
+
+      def default_rails_preview_paths
+        return [] unless defined?(Rails.root) && Dir.exist?("#{Rails.root}/test/components/previews")
+
+        ["#{Rails.root}/test/components/previews"]
+      end
+
+      def default_rails_engines_preview_paths
+        return [] unless defined?(Rails::Engine)
+
+        registered_rails_engines_with_previews.map do |descendant|
+          "#{descendant.root}/test/components/previews"
+        end
+      end
+
+      def registered_rails_engines_with_previews
+        Rails::Engine.descendants.select do |descendant|
+          defined?(descendant.root) && Dir.exist?("#{descendant.root}/test/components/previews")
+        end
+      end
+
+      def default_generate_options
+        options = ActiveSupport::OrderedOptions.new(false)
+        options.preview_path = ""
+        options.path = "app/components"
+        options
+      end
+
+      def default_previews_options
+        options = ActiveSupport::OrderedOptions.new
+        options.controller = "ViewComponentsController"
+        options.route = "/rails/view_components"
+        options.enabled = defined?(Rails.env) && (Rails.env.development? || Rails.env.test?)
+        options.default_layout = nil
+        options.paths = default_preview_paths
+        options
+      end
+    end
+
+    # @!attribute current
+    # @return [ViewComponent::Config]
+    # Returns the current ViewComponent::Config. This is persisted against this
+    # class so that config options remain accessible before the rest of
+    # ViewComponent has loaded. Defaults to an instance of ViewComponent::Config
+    # with all other documented defaults set.
+    class_attribute :current, default: defaults, instance_predicate: false
+
+    def initialize
+      @config = self.class.defaults
+    end
+
+    delegate_missing_to :config
+
+    private
+
+    attr_reader :config
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/configurable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Configurable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def config
+        @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
+          superclass.config.inheritable_copy
+        else
+          ActiveSupport::OrderedOptions.new
+        end
+      end
+
+      def configure
+        yield config
+      end
+    end
+
+    included do
+      next if respond_to?(:config) && config.respond_to?(:view_component) && config.respond_to_missing?(:instrumentation_enabled)
+
+      configure do |config|
+        config.view_component ||= ActiveSupport::InheritableOptions.new
+      end
+
+      def config
+        self.class.config
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/deprecation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module ViewComponent
+  DEPRECATION_HORIZON = "5.0.0"
+  Deprecation = ActiveSupport::Deprecation.new(DEPRECATION_HORIZON, "ViewComponent")
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/engine.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "rails"
+require "view_component/config"
+require "view_component/deprecation"
+
+module ViewComponent
+  class Engine < Rails::Engine # :nodoc:
+    config.view_component = ViewComponent::Config.current
+
+    initializer "view_component.set_configs" do |app|
+      options = app.config.view_component
+
+      %i[generate previews].each do |config_option|
+        options[config_option] ||= ViewComponent::Base.public_send(config_option)
+      end
+      options.instrumentation_enabled = false if options.instrumentation_enabled.nil?
+      options.previews.enabled = (Rails.env.development? || Rails.env.test?) if options.previews.enabled.nil?
+
+      if options.previews.enabled
+        # This is still necessary because when `config.view_component` is declared, `Rails.root` is unspecified.
+        options.previews.paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
+          "#{Rails.root}/test/components/previews"
+        )
+      end
+    end
+
+    initializer "view_component.enable_instrumentation" do |app|
+      ActiveSupport.on_load(:view_component) do
+        if app.config.view_component.instrumentation_enabled.present?
+          ViewComponent::Base.prepend(ViewComponent::Instrumentation)
+        end
+      end
+    end
+
+    initializer "view_component.set_autoload_paths" do |app|
+      options = app.config.view_component
+
+      if options.previews.enabled && !options.previews.paths.empty?
+        paths_to_add = options.previews.paths - ActiveSupport::Dependencies.autoload_paths
+        ActiveSupport::Dependencies.autoload_paths.concat(paths_to_add) if paths_to_add.any?
+      end
+    end
+
+    initializer "view_component.propshaft_support" do |_app|
+      ActiveSupport.on_load(:view_component) do
+        if defined?(Propshaft)
+          include Propshaft::Helper
+        end
+      end
+    end
+
+    config.after_routes_loaded do
+      ActiveSupport.on_load(:view_component) do
+        if defined?(Sprockets::Rails)
+          include Sprockets::Rails::Helper
+
+          app = Rails.application
+
+          # Copy relevant config to VC context
+          # See: https://github.com/rails/sprockets-rails/blob/266ec49f3c7c96018dd75f9dc4f9b62fe3f7eecf/lib/sprockets/railtie.rb#L245
+          self.debug_assets = app.config.assets.debug
+          self.digest_assets = app.config.assets.digest
+          self.assets_prefix = app.config.assets.prefix
+          self.assets_precompile = app.config.assets.precompile
+
+          self.assets_environment = app.assets
+          self.assets_manifest = app.assets_manifest
+
+          self.resolve_assets_with = app.config.assets.resolve_with
+
+          self.check_precompiled_asset = app.config.assets.check_precompiled_asset
+          self.unknown_asset_fallback = app.config.assets.unknown_asset_fallback
+          # Expose the app precompiled asset check to the view
+          self.precompiled_asset_checker = ->(logical_path) { app.asset_precompiled? logical_path }
+        end
+      end
+    end
+
+    initializer "view_component.eager_load_actions" do
+      ActiveSupport.on_load(:after_initialize) do
+        if Rails.application.config.eager_load
+          ActiveSupport::Notifications.instrument("compile.view_component") do
+            ViewComponent::Base.descendants.each(&:__vc_compile)
+          end
+        end
+      end
+    end
+
+    initializer "compiler mode" do |_app|
+      ViewComponent::Compiler.__vc_development_mode = (Rails.env.development? || Rails.env.test?)
+    end
+
+    config.after_initialize do |app|
+      options = app.config.view_component
+
+      if options.previews.enabled
+        app.routes.prepend do
+          preview_controller = options.previews.controller.sub(/Controller$/, "").underscore
+
+          get(
+            options.previews.route,
+            to: "#{preview_controller}#index",
+            as: :preview_view_components,
+            internal: true
+          )
+
+          get(
+            "#{options.previews.route}/*path",
+            to: "#{preview_controller}#previews",
+            as: :preview_view_component,
+            internal: true
+          )
+        end
+      end
+
+      if Rails.env.test?
+        app.routes.prepend do
+          get("_system_test_entrypoint", to: "view_components_system_test#system_test_entrypoint")
+        end
+      end
+
+      app.executor.to_run :before do
+        CompileCache.invalidate! unless ActionView::Base.cache_template_loading
+      end
+    end
+  end
+end