style_capsule 1.3.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,252 +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
-
-      # Deprecated: Use stylesheet_registry instead
-      # @deprecated Use {#stylesheet_registry} instead
-      def head_rendering!
-        stylesheet_registry
-      end
-
-      # Check if component uses head rendering
-      def head_rendering?
-        return false unless defined?(@head_rendering)
-        @head_rendering
-      end
-
-      public :head_rendering?
-
-      # Get the namespace for stylesheet registry
-      def stylesheet_namespace
-        @stylesheet_namespace if defined?(@stylesheet_namespace)
-      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
-      def inline_cache_strategy
-        @inline_cache_strategy if defined?(@inline_cache_strategy)
-      end
-
-      # Get inline cache TTL
-      def inline_cache_ttl
-        @inline_cache_ttl if defined?(@inline_cache_ttl)
-      end
-
-      # Get inline cache proc
-      def inline_cache_proc
-        @inline_cache_proc if defined?(@inline_cache_proc)
-      end
-
-      public :head_rendering?, :stylesheet_namespace, :custom_capsule_id, :inline_cache_strategy, :inline_cache_ttl, :inline_cache_proc
-
-      # 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
-
-      # Set or get CSS scoping strategy
-      #
-      # @param strategy [Symbol, nil] Scoping strategy: :selector_patching (default) or :nesting (omit to get current value)
-      #   - :selector_patching: Adds [data-capsule="..."] prefix to each selector (better browser support)
-      #   - :nesting: Wraps entire CSS in [data-capsule="..."] { ... } (more performant, requires CSS nesting support)
-      # @return [Symbol] The current scoping strategy (default: :selector_patching)
-      # @example Using CSS nesting (requires Chrome 112+, Firefox 117+, Safari 16.5+)
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     css_scoping_strategy :nesting  # More performant, no CSS parsing needed
-      #
-      #     def component_styles
-      #       <<~CSS
-      #         .section { color: red; }
-      #         .heading:hover { opacity: 0.8; }
-      #       CSS
-      #     end
-      #   end
-      #   # Output: [data-capsule="abc123"] { .section { color: red; } .heading:hover { opacity: 0.8; } }
-      # @example Using selector patching (default, better browser support)
-      #   class MyComponent < ApplicationComponent
-      #     include StyleCapsule::ViewComponent
-      #     css_scoping_strategy :selector_patching  # Default
-      #
-      #     def component_styles
-      #       <<~CSS
-      #         .section { color: red; }
-      #       CSS
-      #     end
-      #   end
-      #   # Output: [data-capsule="abc123"] .section { color: red; }
-      def css_scoping_strategy(strategy = nil)
-        if strategy.nil?
-          # Check if this class has a strategy set
-          if defined?(@css_scoping_strategy) && @css_scoping_strategy
-            @css_scoping_strategy
-          # Otherwise, check parent class (for inheritance)
-          elsif superclass.respond_to?(:css_scoping_strategy, true)
-            superclass.css_scoping_strategy
-          else
-            :selector_patching
-          end
-        else
-          unless [:selector_patching, :nesting].include?(strategy)
-            raise ArgumentError, "css_scoping_strategy must be :selector_patching or :nesting (got: #{strategy.inspect})"
-          end
-          @css_scoping_strategy = strategy
-        end
-      end
-
-      public :css_scoping_strategy
+      include StyleCapsule::ComponentClassMethods
     end
 
     # Module that wraps call to add scoped wrapper
@@ -353,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
@@ -388,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?
@@ -433,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
     #
@@ -444,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]
@@ -457,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

@@ -10,13 +10,17 @@ module StyleCapsule
   #
   # Usage in ViewComponent layouts:
   #   def call
-  #     helpers.stylesheet_registrymap_tags
+  #     helpers.stylesheet_registry_tags
   #   end
   #
   # Usage in ViewComponent components:
-  #   def call
-  #     register_stylesheet("stylesheets/user/my_component")
-  #     content_tag(:div, "Content")
+  #   class MyComponent < ApplicationComponent
+  #     style_capsule namespace: :user  # Set default namespace for register_stylesheet
+  #
+  #     def call
+  #       register_stylesheet("stylesheets/user/my_component")  # Uses :user namespace automatically
+  #       content_tag(:div, "Content")
+  #     end
   #   end
   module ViewComponentHelper
     # Register a stylesheet file for head rendering
@@ -28,11 +32,18 @@ module StyleCapsule
     #     content_tag(:div, "Content")
     #   end
     #
+    # 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)
-    # @param namespace [Symbol, String, nil] Optional namespace for separation (nil/blank uses default)
+    # @param namespace [Symbol, String, nil] Optional namespace for separation (nil/blank uses component's default or global default)
     # @param options [Hash] Options for stylesheet_link_tag
     # @return [void]
     def register_stylesheet(file_path, namespace: nil, **options)
+      # Use component's default namespace if not explicitly provided
+      if namespace.nil? && respond_to?(:class) && self.class.respond_to?(:stylesheet_namespace)
+        namespace = self.class.stylesheet_namespace
+      end
       StyleCapsule::StylesheetRegistry.register(file_path, namespace: namespace, **options)
     end
 
@@ -49,9 +60,5 @@ module StyleCapsule
     def stylesheet_registry_tags(namespace: nil)
       StyleCapsule::StylesheetRegistry.render_head_stylesheets(helpers, namespace: namespace)
     end
-
-    # @deprecated Use {#stylesheet_registry_tags} instead.
-    #   This method name will be removed in a future version.
-    alias_method :stylesheet_registrymap_tags, :stylesheet_registry_tags
   end
 end

data/lib/style_capsule.rb

@@ -18,6 +18,7 @@ end
 # @example Phlex Component Usage
 #   class MyComponent < ApplicationComponent
 #     include StyleCapsule::Component
+#     style_capsule namespace: :user  # Configure namespace and other settings
 #
 #     def component_styles
 #       <<~CSS
@@ -29,6 +30,7 @@ end
 # @example ViewComponent Encapsulation Usage
 #   class MyComponent < ApplicationComponent
 #     include StyleCapsule::ViewComponent
+#     style_capsule namespace: :admin  # Configure namespace and other settings
 #
 #     def component_styles
 #       <<~CSS
@@ -51,8 +53,10 @@ end
 #   end
 #
 #   class MyComponent < ApplicationComponent
+#     style_capsule namespace: :user  # Configure namespace
+#
 #     def call
-#       register_stylesheet("stylesheets/user/my_component")
+#       register_stylesheet("stylesheets/user/my_component")  # Uses :user namespace automatically
 #       content_tag(:div, "Content", class: "section")
 #     end
 #   end
@@ -68,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 %>
@@ -81,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/
@@ -90,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,44 +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 head_rendering!: () -> void  # deprecated
-      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
-      def css_scoping_strategy: (Symbol strategy) -> Symbol
+      include ComponentClassMethods
     end
 
     def component_capsule: () -> String
@@ -63,23 +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 head_rendering!: () -> void  # deprecated
-      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
-      def css_scoping_strategy: (Symbol strategy) -> Symbol
+      include ComponentClassMethods
     end
 
     def component_capsule: () -> String
@@ -89,25 +92,21 @@ module StyleCapsule
   module ViewComponentHelper
     def register_stylesheet: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
     def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> String
-    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> String  # deprecated
   end
 
   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
-    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> String  # deprecated
   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_registrymap_tags: (?namespace: Symbol | String | nil) -> void  # deprecated
+    def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> String
   end
 
   class Railtie < Rails::Railtie
   end
 end
-