style_capsule 1.4.0 → 2.0.0

data/lib/style_capsule/view_component.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest/sha1"
+require_relative "component_class_methods"
 # ActiveSupport string extensions are conditionally required in lib/style_capsule.rb
 
 module StyleCapsule
@@ -95,314 +96,7 @@ module StyleCapsule
     end
 
     module ClassMethods
-      # Class-level cache for scoped CSS per component class
-      def css_cache
-        @css_cache ||= {}
-      end
-
-      # Clear the CSS cache for this component class
-      #
-      # Useful for testing or when you want to force CSS reprocessing.
-      # In development, this is automatically called when classes are reloaded.
-      #
-      # @example
-      #   MyComponent.clear_css_cache
-      def clear_css_cache
-        @css_cache = {}
-      end
-
-      # Set or get a custom capsule ID for this component class (useful for testing)
-      #
-      # @param capsule_id [String, nil] The custom capsule ID to use (nil to get current value)
-      # @return [String, nil] The current capsule ID if no argument provided
-      # @example Setting a custom capsule ID
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     capsule_id "test-capsule-123"
-      #   end
-      # @example Getting the current capsule ID
-      #   MyComponent.capsule_id  # => "test-capsule-123" or nil
-      def capsule_id(capsule_id = nil)
-        if capsule_id.nil?
-          @custom_capsule_id if defined?(@custom_capsule_id)
-        else
-          @custom_capsule_id = capsule_id.to_s
-        end
-      end
-
-      # Configure stylesheet registry for head rendering
-      #
-      # Enables head rendering and configures namespace and cache strategy in a single call.
-      # All parameters are optional - calling without arguments enables head rendering with defaults.
-      #
-      # @param namespace [Symbol, String, nil] Namespace identifier (nil/blank uses default)
-      # @param cache_strategy [Symbol, String, Proc, nil] Cache strategy: :none (default), :time, :proc, :file
-      #   - Symbol or String: :none, :time, :proc, :file (or "none", "time", "proc", "file")
-      #   - Proc: Custom cache proc (automatically uses :proc strategy)
-      #     Proc receives: (css_content, capsule_id, namespace) and should return [cache_key, should_cache, expires_at]
-      # @param cache_ttl [Integer, ActiveSupport::Duration, nil] Time-to-live in seconds (for :time strategy). Supports ActiveSupport::Duration (e.g., 1.hour, 30.minutes)
-      # @param cache_proc [Proc, nil] Custom cache proc (for :proc strategy, ignored if cache_strategy is a Proc)
-      #   Proc receives: (css_content, capsule_id, namespace) and should return [cache_key, should_cache, expires_at]
-      # @return [void]
-      # @example Basic usage (enables head rendering with defaults)
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry
-      #   end
-      # @example With namespace
-      #   class AdminComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry namespace: :admin
-      #   end
-      # @example With time-based caching
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry cache_strategy: :time, cache_ttl: 1.hour
-      #   end
-      # @example With custom proc caching
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry cache_strategy: :proc, cache_proc: ->(css, capsule_id, ns) {
-      #       cache_key = "css_#{capsule_id}_#{ns}"
-      #       should_cache = css.length > 100
-      #       expires_at = Time.now + 1800
-      #       [cache_key, should_cache, expires_at]
-      #     }
-      #   end
-      # @example File-based caching (requires class method component_styles)
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry cache_strategy: :file
-      #
-      #     def self.component_styles  # Must be class method for file caching
-      #       <<~CSS
-      #         .section { color: red; }
-      #       CSS
-      #     end
-      #   end
-      # @example All options combined
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry namespace: :admin, cache_strategy: :time, cache_ttl: 1.hour
-      #   end
-      def stylesheet_registry(namespace: nil, cache_strategy: :none, cache_ttl: nil, cache_proc: nil)
-        @head_rendering = true
-        @stylesheet_namespace = namespace unless namespace.nil?
-
-        # Normalize cache_strategy: convert strings to symbols, handle Proc
-        normalized_strategy, normalized_proc = normalize_cache_strategy(cache_strategy, cache_proc)
-        @inline_cache_strategy = normalized_strategy
-        @inline_cache_ttl = cache_ttl
-        @inline_cache_proc = normalized_proc
-      end
-
-      private
-
-      # Normalize cache_strategy to handle Symbol, String, and Proc
-      #
-      # @param cache_strategy [Symbol, String, Proc, nil] Cache strategy
-      # @param cache_proc [Proc, nil] Optional cache proc (ignored if cache_strategy is a Proc)
-      # @return [Array<Symbol, Proc|nil>] Normalized strategy and proc
-      def normalize_cache_strategy(cache_strategy, cache_proc)
-        case cache_strategy
-        when Proc
-          # If cache_strategy is a Proc, use it as the proc and set strategy to :proc
-          [:proc, cache_strategy]
-        when String
-          # Convert string to symbol
-          normalized = cache_strategy.to_sym
-          unless [:none, :time, :proc, :file].include?(normalized)
-            raise ArgumentError, "cache_strategy must be :none, :time, :proc, or :file (got: #{cache_strategy.inspect})"
-          end
-          [normalized, cache_proc]
-        when Symbol
-          unless [:none, :time, :proc, :file].include?(cache_strategy)
-            raise ArgumentError, "cache_strategy must be :none, :time, :proc, or :file (got: #{cache_strategy.inspect})"
-          end
-          [cache_strategy, cache_proc]
-        when nil
-          [:none, nil]
-        else
-          raise ArgumentError, "cache_strategy must be a Symbol, String, or Proc (got: #{cache_strategy.class})"
-        end
-      end
-
-      # Check if component uses head rendering (checks instance variable, then parent class, defaults to false)
-      #
-      # @return [Boolean] Whether head rendering is enabled (default: false)
-      def head_rendering?
-        if defined?(@head_rendering)
-          @head_rendering
-        elsif superclass.respond_to?(:head_rendering?, true)
-          superclass.head_rendering?
-        else
-          false
-        end
-      end
-
-      public :head_rendering?
-
-      # Get the namespace for stylesheet registry (checks instance variable, then parent class, defaults to nil)
-      #
-      # @return [Symbol, String, nil] The namespace identifier (default: nil)
-      def stylesheet_namespace
-        if defined?(@stylesheet_namespace) && @stylesheet_namespace
-          @stylesheet_namespace
-        elsif superclass.respond_to?(:stylesheet_namespace, true)
-          superclass.stylesheet_namespace
-        end
-      end
-
-      # Configure StyleCapsule settings
-      #
-      # All settings support class inheritance - child classes inherit settings from parent classes
-      # and can override them by calling style_capsule again with different values.
-      #
-      # @param namespace [Symbol, String, nil] Default namespace for stylesheets
-      # @param cache_strategy [Symbol, String, Proc, nil] Cache strategy: :none (default), :time, :proc, :file
-      # @param cache_ttl [Integer, ActiveSupport::Duration, nil] Time-to-live in seconds (for :time strategy)
-      # @param cache_proc [Proc, nil] Custom cache proc (for :proc strategy)
-      # @param scoping_strategy [Symbol, nil] CSS scoping strategy: :selector_patching (default) or :nesting
-      # @param head_rendering [Boolean, nil] Enable head rendering (default: true if any option is set, false otherwise)
-      # @return [void]
-      # @example Basic usage with namespace
-      #   class AdminComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     style_capsule namespace: :admin
-      #
-      #     def call
-      #       register_stylesheet("stylesheets/admin/dashboard")  # Uses :admin namespace automatically
-      #       content_tag(:div, "Content")
-      #     end
-      #   end
-      # @example With all options
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     style_capsule(
-      #       namespace: :user,
-      #       cache_strategy: :time,
-      #       cache_ttl: 1.hour,
-      #       scoping_strategy: :nesting
-      #     )
-      #   end
-      # @example Inheritance - child class inherits parent settings
-      #   class BaseComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     style_capsule namespace: :admin, cache_strategy: :time, cache_ttl: 1.hour
-      #   end
-      #
-      #   class ChildComponent < BaseComponent
-      #     # Inherits namespace: :admin, cache_strategy: :time, cache_ttl: 1.hour
-      #     # Can override specific settings:
-      #     style_capsule namespace: :user  # Overrides namespace, keeps cache settings
-      #   end
-      def style_capsule(namespace: nil, cache_strategy: nil, cache_ttl: nil, cache_proc: nil, scoping_strategy: nil, head_rendering: nil)
-        # Set namespace (stored in instance variable, but getter checks parent class for inheritance)
-        if namespace
-          @stylesheet_namespace = namespace
-        end
-
-        # Configure cache strategy if provided
-        if cache_strategy || cache_ttl || cache_proc
-          normalized_strategy, normalized_proc = normalize_cache_strategy(cache_strategy || :none, cache_proc)
-          @inline_cache_strategy = normalized_strategy
-          # Explicitly set cache_ttl (even if nil) to override parent's value when cache settings are changed
-          @inline_cache_ttl = cache_ttl
-          @inline_cache_proc = normalized_proc
-        end
-
-        # Configure CSS scoping strategy if provided
-        if scoping_strategy
-          unless [:selector_patching, :nesting].include?(scoping_strategy)
-            raise ArgumentError, "scoping_strategy must be :selector_patching or :nesting (got: #{scoping_strategy.inspect})"
-          end
-          @css_scoping_strategy = scoping_strategy
-        end
-
-        # Enable head rendering if explicitly set or if any option is provided (except scoping_strategy)
-        if head_rendering.nil?
-          @head_rendering = true if namespace || cache_strategy || cache_ttl || cache_proc
-        else
-          @head_rendering = head_rendering
-        end
-      end
-
-      # Get the custom scope ID if set (alias for capsule_id getter)
-      def custom_capsule_id
-        @custom_capsule_id if defined?(@custom_capsule_id)
-      end
-
-      # Get inline cache strategy (checks instance variable, then parent class, defaults to nil)
-      #
-      # @return [Symbol, nil] The cache strategy (default: nil)
-      def inline_cache_strategy
-        if defined?(@inline_cache_strategy) && @inline_cache_strategy
-          @inline_cache_strategy
-        elsif superclass.respond_to?(:inline_cache_strategy, true)
-          superclass.inline_cache_strategy
-        end
-      end
-
-      # Get inline cache TTL (checks instance variable, then parent class, defaults to nil)
-      #
-      # @return [Integer, ActiveSupport::Duration, nil] The cache TTL (default: nil)
-      def inline_cache_ttl
-        if defined?(@inline_cache_ttl)
-          @inline_cache_ttl
-        elsif superclass.respond_to?(:inline_cache_ttl, true)
-          superclass.inline_cache_ttl
-        end
-      end
-
-      # Get inline cache proc (checks instance variable, then parent class, defaults to nil)
-      #
-      # @return [Proc, nil] The cache proc (default: nil)
-      def inline_cache_proc
-        if defined?(@inline_cache_proc)
-          @inline_cache_proc
-        elsif superclass.respond_to?(:inline_cache_proc, true)
-          superclass.inline_cache_proc
-        end
-      end
-
-      public :head_rendering?, :stylesheet_namespace, :style_capsule, :custom_capsule_id, :inline_cache_strategy, :inline_cache_ttl, :inline_cache_proc
-
-      # Get CSS scoping strategy (checks instance variable, then parent class, defaults to :selector_patching)
-      #
-      # @return [Symbol] The current scoping strategy (default: :selector_patching)
-      def css_scoping_strategy
-        if defined?(@css_scoping_strategy) && @css_scoping_strategy
-          @css_scoping_strategy
-        elsif superclass.respond_to?(:css_scoping_strategy, true)
-          superclass.css_scoping_strategy
-        else
-          :selector_patching
-        end
-      end
-
-      public :css_scoping_strategy
-
-      # Set or get options for stylesheet_link_tag when using file-based caching
-      #
-      # @param options [Hash, nil] Options to pass to stylesheet_link_tag (e.g., "data-turbo-track": "reload", omit to get current value)
-      # @return [Hash, nil] The current stylesheet link options if no argument provided
-      # @example Setting stylesheet link options
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     stylesheet_registry cache_strategy: :file
-      #     stylesheet_link_options "data-turbo-track": "reload"
-      #   end
-      # @example Getting the current options
-      #   MyComponent.stylesheet_link_options  # => {"data-turbo-track" => "reload"} or nil
-      def stylesheet_link_options(options = nil)
-        if options.nil?
-          @stylesheet_link_options if defined?(@stylesheet_link_options)
-        else
-          @stylesheet_link_options = options
-        end
-      end
-
-      public :stylesheet_link_options
+      include StyleCapsule::ComponentClassMethods
     end
 
     # Module that wraps call to add scoped wrapper
@@ -415,8 +109,11 @@ module StyleCapsule
           # Get content from original call method
           content_html = super
 
+          # Get wrapper tag
+          tag = self.class.wrapper_tag
+
           # Wrap content in scoped element
-          scoped_wrapper = helpers.content_tag(:div, content_html.html_safe, data: {capsule: component_capsule})
+          scoped_wrapper = helpers.content_tag(tag, content_html.html_safe, data: {capsule: component_capsule})
 
           # Combine styles and wrapped content
           (styles_html + scoped_wrapper).html_safe
@@ -450,6 +147,7 @@ module StyleCapsule
     # File caching is only allowed for class method component_styles.
     #
     # @return [String] HTML string with style tag or empty string
+    # rubocop:disable Metrics/AbcSize -- coordinates head vs body rendering, caching, and registry
     def render_capsule_styles
       css_content = component_styles_content
       return "".html_safe if css_content.nil? || css_content.to_s.strip.empty?
@@ -495,6 +193,7 @@ module StyleCapsule
         helpers.content_tag(:style, scoped_css.html_safe, type: "text/css")
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # Check if component should use head rendering
     #
@@ -506,11 +205,10 @@ module StyleCapsule
 
     # Scope CSS and return scoped CSS with attribute selectors
     def scope_css(css_content)
-      # Use class-level cache to avoid reprocessing same CSS
-      # Include capsule_id and scoping strategy in cache key
       capsule_id = component_capsule
       scoping_strategy = self.class.css_scoping_strategy
-      cache_key = "#{self.class.name}:#{capsule_id}:#{scoping_strategy}"
+      css_fingerprint = Digest::SHA1.hexdigest(css_content.to_s)
+      cache_key = "#{self.class.name}:#{capsule_id}:#{scoping_strategy}:#{css_fingerprint}"
 
       if self.class.css_cache.key?(cache_key)
         return self.class.css_cache[cache_key]
@@ -519,15 +217,12 @@ module StyleCapsule
       # Use the configured scoping strategy
       scoped_css = case scoping_strategy
       when :nesting
-        CssProcessor.scope_with_nesting(css_content, capsule_id)
+        CssProcessor.scope_with_nesting(css_content, capsule_id, component_class: self.class)
       else # :selector_patching (default)
-        CssProcessor.scope_selectors(css_content, capsule_id)
+        CssProcessor.scope_selectors(css_content, capsule_id, component_class: self.class)
       end
 
-      # Cache at class level (one style block per component type/scope/strategy combination)
-      self.class.css_cache[cache_key] = scoped_css
-
-      scoped_css
+      self.class.store_css_cache(cache_key, scoped_css)
     end
 
     # Generate a unique capsule ID based on component class name (per-component-type)

data/lib/style_capsule/view_component_helper.rb

@@ -15,7 +15,7 @@ module StyleCapsule
   #
   # Usage in ViewComponent components:
   #   class MyComponent < ApplicationComponent
-  #     styles_namespace :user  # Set default namespace
+  #     style_capsule namespace: :user  # Set default namespace for register_stylesheet
   #
   #     def call
   #       register_stylesheet("stylesheets/user/my_component")  # Uses :user namespace automatically
@@ -32,7 +32,7 @@ module StyleCapsule
     #     content_tag(:div, "Content")
     #   end
     #
-    # If the component has a default namespace set via styles_namespace or stylesheet_registry,
+    # If the component has a default namespace set via style_capsule or stylesheet_registry,
     # it will be used automatically when namespace is not explicitly provided.
     #
     # @param file_path [String] Path to stylesheet (relative to app/assets/stylesheets)

data/lib/style_capsule.rb

@@ -72,9 +72,12 @@ end
 #   <%= stylesheet_registry_tags(namespace: :admin) %>
 #
 # @example Namespace Support
-#   # Register stylesheets with namespaces
-#   StyleCapsule::StylesheetRegistry.register('stylesheets/admin/dashboard', namespace: :admin)
-#   StyleCapsule::StylesheetRegistry.register('stylesheets/user/profile', namespace: :user)
+#   # Eager registrations (boot / class load; process-wide manifest)
+#   StyleCapsule::StylesheetRegistry.register_eager('stylesheets/admin/dashboard', namespace: :admin)
+#   StyleCapsule::StylesheetRegistry.register_eager('stylesheets/user/profile', namespace: :user)
+#
+#   # Render-time registrations (request-scoped; also picked up by HeadInjectionMiddleware)
+#   StyleCapsule::StylesheetRegistry.register('stylesheets/page', namespace: :user)
 #
 #   # Render all namespaces (default)
 #   <%= stylesheet_registry_tags %>
@@ -85,7 +88,7 @@ end
 # @example File-Based Caching (HTTP Caching)
 #   class MyComponent < ApplicationComponent
 #     include StyleCapsule::Component
-#     stylesheet_registry cache_strategy: :file  # Writes CSS to files for HTTP caching
+#     style_capsule cache_strategy: :file  # Writes CSS to files for HTTP caching
 #   end
 #
 #   # CSS files are written to app/assets/builds/capsules/
@@ -94,6 +97,8 @@ end
 module StyleCapsule
   require_relative "style_capsule/version"
   require_relative "style_capsule/instrumentation"
+  require_relative "style_capsule/asset_path"
+  require_relative "style_capsule/helper_scope_cache"
   require_relative "style_capsule/css_processor"
   require_relative "style_capsule/css_file_writer"
   require_relative "style_capsule/stylesheet_registry"

data/lib/tasks/style_capsule.rake

@@ -16,7 +16,20 @@ namespace :style_capsule do
   end
 end
 
-# Hook into Rails asset precompilation (similar to Tailwind CSS)
+# Hook into Rails asset precompilation (similar to Tailwind CSS).
+# Set `config.style_capsule.run_on_precompile = false` to skip.
+task "style_capsule:precompile_hook" => :environment do
+  cfg = Rails.application.config
+  run = if cfg.respond_to?(:style_capsule) && cfg.style_capsule
+    cfg.style_capsule.run_on_precompile != false
+  else
+    true
+  end
+  next unless run
+
+  Rake::Task["style_capsule:build"].invoke
+end
+
 if defined?(Rails)
-  Rake::Task["assets:precompile"].enhance(["style_capsule:build"]) if Rake::Task.task_defined?("assets:precompile")
+  Rake::Task["assets:precompile"].enhance(["style_capsule:precompile_hook"]) if Rake::Task.task_defined?("assets:precompile")
 end

data/sig/style_capsule.rbs

@@ -1,9 +1,13 @@
 module StyleCapsule
   VERSION: String
 
+  module AssetPath
+    def self.validate_logical_path!: (String path) -> String
+  end
+
   module CssProcessor
-    def self.scope_selectors: (String css_string, String capsule_id) -> String
-    def self.scope_with_nesting: (String css_string, String capsule_id) -> String
+    def self.scope_selectors: (String css_string, String capsule_id, ?component_class: Class | String | nil) -> String
+    def self.scope_with_nesting: (String css_string, String capsule_id, ?component_class: Class | String | nil) -> String
     def self.strip_comments: (String css) -> String
   end
 
@@ -17,43 +21,59 @@ module StyleCapsule
     def self.enabled?: () -> bool
   end
 
-  class StylesheetRegistry < ActiveSupport::CurrentAttributes
+  # At runtime inherits Object when ActiveSupport::CurrentAttributes is unavailable.
+  class StylesheetRegistry
     DEFAULT_NAMESPACE: Symbol
 
     def self.normalize_namespace: (Symbol | String | nil namespace) -> Symbol
     def self.register: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
+    def self.register_eager: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
     def self.register_inline: (String css_content, ?namespace: Symbol | String | nil, ?capsule_id: String | nil, ?cache_key: String | nil, ?cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?component_class: Class | nil, ?stylesheet_link_options: Hash[untyped, untyped] | nil) -> void
     def self.cached_inline: (String cache_key, cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?css_content: String | nil, ?capsule_id: String | nil, ?namespace: Symbol | nil) -> String | nil
     def self.cache_inline_css: (String cache_key, String css_content, cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?capsule_id: String | nil, ?namespace: Symbol | nil) -> void
     def self.clear_inline_cache: (?String cache_key) -> void
     def self.cleanup_expired_cache: () -> Integer
-    def self.manifest_files: () -> Hash[Symbol, Set[Hash[Symbol, untyped]]]
+    def self.manifest_files: () -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
     def self.request_inline_stylesheets: () -> Hash[Symbol, Array[Hash[Symbol, untyped]]]
+    def self.request_stylesheet_files: () -> Hash[Symbol, Hash[String, Hash[Symbol, untyped]]]
     def self.stylesheets_for: (?namespace: Symbol | String | nil) -> Array[Hash[Symbol, untyped]]
     def self.clear: (?namespace: Symbol | String | nil) -> void
     def self.clear_manifest: (?namespace: Symbol | String | nil) -> void
     def self.render_head_stylesheets: (?ActionView::Base | nil view_context, ?namespace: Symbol | String | nil) -> String
+    def self.inject_pending_head_stylesheets: (String html, ?ActionView::Base | nil view_context) -> String
+    def self.pending_head_stylesheets?: () -> bool
     def self.any?: (?namespace: Symbol | String | nil) -> bool
   end
 
+  class HeadInjectionMiddleware
+    def initialize: (untyped app) -> void
+    def call: (Hash[Symbol, untyped] env) -> [Integer, Hash[String, String], untyped]
+  end
+
+  module ComponentClassMethods
+    MAX_CSS_CACHE_ENTRIES: Integer
+    def css_cache: () -> Hash[String, String]
+    def store_css_cache: (String cache_key, String scoped_css) -> String
+    def clear_css_cache: () -> void
+    def capsule_id: () -> String | nil
+    def capsule_id: (String capsule_id) -> String
+    def stylesheet_registry: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil) -> void
+    def style_capsule: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol | String | Proc | nil, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?scoping_strategy: Symbol | nil, ?head_rendering: bool | nil, ?tag: Symbol | String | nil) -> void
+    def head_rendering?: () -> bool
+    def stylesheet_namespace: () -> Symbol | String | nil
+    def custom_capsule_id: () -> String | nil
+    def inline_cache_strategy: () -> Symbol | nil
+    def inline_cache_strategy: (Symbol strategy, ?ttl: Integer | nil, ?cache_proc: Proc | nil) -> Symbol
+    def inline_cache_ttl: () -> Integer | ActiveSupport::Duration | nil
+    def inline_cache_proc: () -> Proc | nil
+    def stylesheet_link_options: () -> Hash[untyped, untyped] | nil
+    def stylesheet_link_options: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+    def css_scoping_strategy: () -> Symbol
+  end
+
   module Component
     module ClassMethods
-      def css_cache: () -> Hash[String, String]
-      def clear_css_cache: () -> void
-      def capsule_id: () -> String | nil
-      def capsule_id: (String capsule_id) -> String
-      def stylesheet_registry: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil) -> void
-      def style_capsule: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol | String | Proc | nil, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?scoping_strategy: Symbol | nil, ?head_rendering: bool | nil) -> void
-      def head_rendering?: () -> bool
-      def stylesheet_namespace: () -> Symbol | String | nil
-      def custom_capsule_id: () -> String | nil
-      def inline_cache_strategy: () -> Symbol | nil
-      def inline_cache_strategy: (Symbol strategy, ?ttl: Integer | nil, ?cache_proc: Proc | nil) -> Symbol
-      def inline_cache_ttl: () -> Integer | ActiveSupport::Duration | nil
-      def inline_cache_proc: () -> Proc | nil
-      def stylesheet_link_options: () -> Hash[untyped, untyped] | nil
-      def stylesheet_link_options: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
-      def css_scoping_strategy: () -> Symbol
+      include ComponentClassMethods
     end
 
     def component_capsule: () -> String
@@ -62,22 +82,7 @@ module StyleCapsule
 
   module ViewComponent
     module ClassMethods
-      def css_cache: () -> Hash[String, String]
-      def clear_css_cache: () -> void
-      def capsule_id: () -> String | nil
-      def capsule_id: (String capsule_id) -> String
-      def stylesheet_registry: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil) -> void
-      def style_capsule: (?namespace: Symbol | String | nil, ?cache_strategy: Symbol | String | Proc | nil, ?cache_ttl: Integer | ActiveSupport::Duration | nil, ?cache_proc: Proc | nil, ?scoping_strategy: Symbol | nil, ?head_rendering: bool | nil) -> void
-      def head_rendering?: () -> bool
-      def stylesheet_namespace: () -> Symbol | String | nil
-      def custom_capsule_id: () -> String | nil
-      def inline_cache_strategy: () -> Symbol | nil
-      def inline_cache_strategy: (Symbol strategy, ?ttl: Integer | nil, ?cache_proc: Proc | nil) -> Symbol
-      def inline_cache_ttl: () -> Integer | ActiveSupport::Duration | nil
-      def inline_cache_proc: () -> Proc | nil
-      def stylesheet_link_options: () -> Hash[untyped, untyped] | nil
-      def stylesheet_link_options: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
-      def css_scoping_strategy: () -> Symbol
+      include ComponentClassMethods
     end
 
     def component_capsule: () -> String
@@ -92,17 +97,16 @@ module StyleCapsule
   module Helper
     def generate_capsule_id: (String css_content) -> String
     def scope_css: (String css_content, String capsule_id) -> String
-    def style_capsule: (?String css_content, ?capsule_id: String | nil) { () -> String } -> String
+    def style_capsule: (?String css_content, ?capsule_id: String | nil, ?tag: Symbol | String) { () -> String } -> String
     def register_stylesheet: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
     def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> String
   end
 
   module PhlexHelper
     def register_stylesheet: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
-    def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> void
+    def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> String
   end
 
   class Railtie < Rails::Railtie
   end
 end
-