style_capsule 1.0.2 → 1.2.0

data/lib/style_capsule/standalone_helper.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "cgi"
+
+module StyleCapsule
+  # Standalone helper module for use without Rails
+  #
+  # This module provides basic HTML generation and CSS scoping functionality
+  # without requiring Rails ActionView helpers. It can be included in any
+  # framework's view context or used directly.
+  #
+  # @example Usage in Sinatra
+  #   class MyApp < Sinatra::Base
+  #     helpers StyleCapsule::StandaloneHelper
+  #   end
+  #
+  # @example Usage in plain Ruby
+  #   class MyView
+  #     include StyleCapsule::StandaloneHelper
+  #   end
+  #
+  # @example Usage in ERB (non-Rails)
+  #   # In your ERB template context
+  #   include StyleCapsule::StandaloneHelper
+  #   style_capsule do
+  #     "<style>.section { color: red; }</style><div class='section'>Content</div>"
+  #   end
+  module StandaloneHelper
+    # Maximum HTML content size (10MB) to prevent DoS attacks
+    MAX_HTML_SIZE = 10_000_000
+
+    # Generate capsule ID based on caller location for uniqueness
+    def generate_capsule_id(css_content)
+      # Use caller location + CSS content for uniqueness
+      caller_info = caller_locations(1, 1).first
+      capsule_key = "#{caller_info.path}:#{caller_info.lineno}:#{css_content}"
+      "a#{Digest::SHA1.hexdigest(capsule_key)}"[0, 8]
+    end
+
+    # Scope CSS content and return scoped CSS
+    def scope_css(css_content, capsule_id)
+      # Use thread-local cache to avoid reprocessing
+      cache_key = "style_capsule_#{capsule_id}"
+
+      if Thread.current[cache_key]
+        return Thread.current[cache_key]
+      end
+
+      scoped_css = CssProcessor.scope_selectors(css_content, capsule_id)
+      Thread.current[cache_key] = scoped_css
+      scoped_css
+    end
+
+    # Generate HTML tag without Rails helpers
+    #
+    # @param tag [String, Symbol] HTML tag name
+    # @param content [String, nil] Tag content (or use block)
+    # @param options [Hash] HTML attributes
+    # @param block [Proc] Block for tag content
+    # @return [String] HTML string
+    def content_tag(tag, content = nil, **options, &block)
+      tag_name = tag.to_s
+      content = capture(&block) if block_given? && content.nil?
+      content ||= ""
+
+      attrs = options.map do |k, v|
+        if v.is_a?(Hash)
+          # Handle nested attributes like data: { capsule: "abc" }
+          v.map { |nk, nv| %(#{k}-#{nk}="#{escape_html_attr(nv)}") }.join(" ")
+        else
+          %(#{k}="#{escape_html_attr(v)}")
+        end
+      end.join(" ")
+
+      attrs = " #{attrs}" unless attrs.empty?
+      "<#{tag_name}#{attrs}>#{content}</#{tag_name}>"
+    end
+
+    # Capture block content (simplified version without Rails)
+    #
+    # @param block [Proc] Block to capture
+    # @return [String] Captured content
+    def capture(&block)
+      return "" unless block_given?
+      block.call.to_s
+    end
+
+    # Mark string as HTML-safe (for compatibility)
+    #
+    # @param string [String] String to mark as safe
+    # @return [String] HTML-safe string
+    def html_safe(string)
+      # In non-Rails context, just return the string
+      # If ActiveSupport is available, use its html_safe
+      if string.respond_to?(:html_safe)
+        string.html_safe
+      else
+        string
+      end
+    end
+
+    # Raw string (no HTML escaping)
+    #
+    # @param string [String] String to return as-is
+    # @return [String] Raw string
+    def raw(string)
+      html_safe(string.to_s)
+    end
+
+    # ERB helper: automatically wraps content in scoped div and processes CSS
+    #
+    # @param css_content [String, nil] CSS content (or extract from block)
+    # @param capsule_id [String, nil] Optional capsule ID
+    # @param content_block [Proc] Block containing HTML content
+    # @return [String] HTML with scoped CSS and wrapped content
+    def style_capsule(css_content = nil, capsule_id: nil, &content_block)
+      html_content = nil
+
+      # If CSS content is provided as argument, use it
+      # Otherwise, extract from content block
+      if css_content.nil? && block_given?
+        full_content = capture(&content_block)
+
+        # Validate HTML content size to prevent DoS attacks
+        if full_content.bytesize > MAX_HTML_SIZE
+          raise ArgumentError, "HTML content exceeds maximum size of #{MAX_HTML_SIZE} bytes (got #{full_content.bytesize} bytes)"
+        end
+
+        # Extract <style> tags from content
+        style_match = full_content.match(/<style[^>]*>(.*?)<\/style>/m)
+        if style_match
+          css_content = style_match[1]
+          html_content = full_content.sub(/<style[^>]*>.*?<\/style>/m, "").strip
+        else
+          css_content = nil
+          html_content = full_content
+        end
+      elsif css_content && block_given?
+        html_content = capture(&content_block)
+      elsif css_content && !block_given?
+        # CSS provided but no content block - just return scoped CSS
+        capsule_id ||= generate_capsule_id(css_content)
+        scoped_css = scope_css(css_content, capsule_id)
+        return content_tag(:style, raw(scoped_css), type: "text/css")
+      else
+        return ""
+      end
+
+      # If no CSS, just return content
+      return html_safe(html_content) if css_content.nil? || css_content.to_s.strip.empty?
+
+      # Use provided capsule_id or generate one
+      capsule_id ||= generate_capsule_id(css_content)
+      scoped_css = scope_css(css_content, capsule_id)
+
+      # Render style tag and wrapped content
+      style_tag = content_tag(:style, raw(scoped_css), type: "text/css")
+      wrapped_content = content_tag(:div, raw(html_content), data: {capsule: capsule_id})
+
+      html_safe(style_tag + wrapped_content)
+    end
+
+    # Register a stylesheet file for head rendering
+    #
+    # @param file_path [String] Path to stylesheet
+    # @param namespace [Symbol, String, nil] Optional namespace
+    # @param options [Hash] Options for stylesheet link tag
+    # @return [void]
+    def register_stylesheet(file_path, namespace: nil, **options)
+      StyleCapsule::StylesheetRegistry.register(file_path, namespace: namespace, **options)
+    end
+
+    # Render StyleCapsule registered stylesheets
+    #
+    # @param namespace [Symbol, String, nil] Optional namespace to render
+    # @return [String] HTML-safe string with stylesheet tags
+    def stylesheet_registry_tags(namespace: nil)
+      StyleCapsule::StylesheetRegistry.render_head_stylesheets(self, 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
+
+    private
+
+    # Escape HTML attribute value
+    #
+    # @param value [String] Value to escape
+    # @return [String] Escaped value
+    def escape_html_attr(value)
+      CGI.escapeHTML(value.to_s)
+    end
+  end
+end

data/lib/style_capsule/stylesheet_registry.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
-require "active_support/current_attributes"
-
 module StyleCapsule
+  # Helper to determine the parent class for StylesheetRegistry
+  # ActiveSupport::CurrentAttributes is optional - if ActiveSupport is loaded,
+  # it will be available. Otherwise, we fall back to Object.
+  #
+  # This is evaluated at class definition time, so it can't be stubbed.
+  # For testing fallback paths, use the instance methods that check availability.
+  def self.stylesheet_registry_parent_class
+    defined?(ActiveSupport::CurrentAttributes) ? ActiveSupport::CurrentAttributes : Object
+  end
+
   # Hybrid registry for stylesheet files that need to be injected into <head>
   #
   # Uses a process-wide manifest for static file paths (like Propshaft) and request-scoped
@@ -52,7 +60,7 @@ module StyleCapsule
   #       body(&block)
   #     end
   #   end
-  class StylesheetRegistry < ActiveSupport::CurrentAttributes
+  class StylesheetRegistry < StyleCapsule.stylesheet_registry_parent_class
     # Default namespace for backward compatibility
     DEFAULT_NAMESPACE = :default
 
@@ -68,10 +76,74 @@ module StyleCapsule
     @last_cleanup_time = nil # rubocop:disable Style/ClassVars
 
     # Request-scoped storage for inline CSS only
-    attribute :inline_stylesheets
+    # Only define attribute if we're inheriting from CurrentAttributes
+    if defined?(ActiveSupport::CurrentAttributes) && self < ActiveSupport::CurrentAttributes
+      attribute :inline_stylesheets
+    end
 
     class << self
       attr_reader :manifest, :inline_cache
+
+      # Get current time (ActiveSupport::Time.current or Time.now fallback)
+      def current_time
+        if defined?(Time) && Time.respond_to?(:current)
+          Time.current
+        else
+          # rubocop:disable Rails/TimeZone
+          # Time.now is intentional fallback for non-Rails usage when Time.current is unavailable
+          Time.now
+          # rubocop:enable Rails/TimeZone
+        end
+      end
+
+      # Check if we're using ActiveSupport::CurrentAttributes
+      # This method can be stubbed in tests to test fallback paths
+      def using_current_attributes?
+        defined?(ActiveSupport::CurrentAttributes) && self < ActiveSupport::CurrentAttributes
+      end
+
+      # Get inline stylesheets (thread-local fallback if not using CurrentAttributes)
+      def inline_stylesheets
+        if using_current_attributes?
+          # When using CurrentAttributes, access the instance attribute
+          # CurrentAttributes automatically provides access to instance attributes
+          inst = instance
+          inst&.inline_stylesheets || {}
+        else
+          Thread.current[:style_capsule_inline_stylesheets] ||= {}
+        end
+      end
+
+      # Set inline stylesheets (thread-local fallback if not using CurrentAttributes)
+      def inline_stylesheets=(value)
+        if using_current_attributes?
+          # When using CurrentAttributes, set via the instance
+          inst = instance
+          inst.inline_stylesheets = value if inst
+        else
+          Thread.current[:style_capsule_inline_stylesheets] = value
+        end
+      end
+
+      # Get instance (for CurrentAttributes compatibility)
+      def instance
+        if using_current_attributes?
+          # Call the CurrentAttributes instance method from parent class
+          super
+        else
+          # Return a simple object that responds to inline_stylesheets
+          # This is mainly for compatibility with code that might call instance.inline_stylesheets
+          registry_class = self
+          @_standalone_instance ||= begin
+            obj = Object.new
+            obj.define_singleton_method(:inline_stylesheets) { registry_class.inline_stylesheets }
+            obj.define_singleton_method(:inline_stylesheets=) { |v| registry_class.inline_stylesheets = v }
+            obj
+          end
+        end
+      end
+
+      private
     end
 
     # Normalize namespace (nil/blank becomes DEFAULT_NAMESPACE)
@@ -177,14 +249,14 @@ module StyleCapsule
       final_css = cached_css || css_content
 
       # Store in request-scoped registry
-      registry = instance.inline_stylesheets || {}
+      registry = inline_stylesheets
       registry[ns] ||= []
       registry[ns] << {
         type: :inline,
         css_content: final_css,
         capsule_id: capsule_id
       }
-      instance.inline_stylesheets = registry
+      self.inline_stylesheets = registry
 
       # Cache the CSS if strategy is enabled and not already cached
       if cache_strategy != :none && cache_key && !cached_css && cache_strategy != :file
@@ -216,7 +288,7 @@ module StyleCapsule
       # Check expiration based on strategy
       case cache_strategy
       when :time
-        return nil if cache_ttl && cached_entry[:expires_at] && Time.current > cached_entry[:expires_at]
+        return nil if cache_ttl && cached_entry[:expires_at] && current_time > cached_entry[:expires_at]
       when :proc
         return nil unless cache_proc
         # Proc should validate cache entry
@@ -242,7 +314,13 @@ module StyleCapsule
 
       case cache_strategy
       when :time
-        expires_at = cache_ttl ? Time.current + cache_ttl : nil
+        # Handle ActiveSupport::Duration (e.g., 1.hour) or integer seconds
+        ttl_seconds = if cache_ttl.respond_to?(:to_i)
+          cache_ttl.to_i
+        else
+          cache_ttl
+        end
+        expires_at = ttl_seconds ? current_time + ttl_seconds : nil
       when :proc
         if cache_proc
           _key, _should_cache, proc_expires = cache_proc.call(css_content, capsule_id, namespace)
@@ -252,7 +330,7 @@ module StyleCapsule
 
       @inline_cache[cache_key] = {
         css_content: css_content,
-        cached_at: Time.current,
+        cached_at: current_time,
         expires_at: expires_at
       }
     end
@@ -287,18 +365,18 @@ module StyleCapsule
     def self.cleanup_expired_cache
       return 0 if @inline_cache.empty?
 
-      current_time = Time.current
+      now = current_time
       expired_keys = []
 
       @inline_cache.each do |cache_key, entry|
         # Remove entries that have an expires_at time and it's in the past
-        if entry[:expires_at] && current_time > entry[:expires_at]
+        if entry[:expires_at] && now > entry[:expires_at]
           expired_keys << cache_key
         end
       end
 
       expired_keys.each { |key| @inline_cache.delete(key) }
-      @last_cleanup_time = current_time
+      @last_cleanup_time = now
 
       expired_keys.size
     end
@@ -314,7 +392,7 @@ module StyleCapsule
       # Cleanup every 5 minutes (300 seconds) to balance memory usage and performance
       cleanup_interval = 300
 
-      if @last_cleanup_time.nil? || (Time.current - @last_cleanup_time) > cleanup_interval
+      if @last_cleanup_time.nil? || (current_time - @last_cleanup_time) > cleanup_interval
         cleanup_expired_cache
       end
     end
@@ -332,7 +410,7 @@ module StyleCapsule
     #
     # @return [Hash<Symbol, Array<Hash>>] Hash of namespace => array of inline stylesheet registrations
     def self.request_inline_stylesheets
-      instance.inline_stylesheets || {}
+      inline_stylesheets
     end
 
     # Get all stylesheets (files + inline) for a specific namespace
@@ -361,12 +439,12 @@ module StyleCapsule
     # @return [void]
     def self.clear(namespace: nil)
       if namespace.nil?
-        instance.inline_stylesheets = {}
+        self.inline_stylesheets = {}
       else
         ns = normalize_namespace(namespace)
-        registry = instance.inline_stylesheets || {}
+        registry = inline_stylesheets
         registry.delete(ns)
-        instance.inline_stylesheets = registry
+        self.inline_stylesheets = registry
       end
     end
 
@@ -411,7 +489,7 @@ module StyleCapsule
         end
 
         clear # Clear request-scoped inline CSS only
-        return "".html_safe if all_stylesheets.empty?
+        return safe_string("") if all_stylesheets.empty?
 
         all_stylesheets.map do |stylesheet|
           if stylesheet[:type] == :inline
@@ -419,7 +497,7 @@ module StyleCapsule
           else
             render_file_stylesheet(stylesheet, view_context)
           end
-        end.join("\n").html_safe
+        end.join("\n").then { |s| safe_string(s) }
 
       else
         # Render specific namespace
@@ -427,7 +505,7 @@ module StyleCapsule
         stylesheets = stylesheets_for(namespace: ns).dup
         clear(namespace: ns) # Clear request-scoped inline CSS only
 
-        return "".html_safe if stylesheets.empty?
+        return safe_string("") if stylesheets.empty?
 
         stylesheets.map do |stylesheet|
           if stylesheet[:type] == :inline
@@ -435,7 +513,7 @@ module StyleCapsule
           else
             render_file_stylesheet(stylesheet, view_context)
           end
-        end.join("\n").html_safe
+        end.join("\n").then { |s| safe_string(s) }
 
       end
     end
@@ -473,7 +551,7 @@ module StyleCapsule
         # Fallback if no view context
         href = "/assets/#{file_path}.css"
         tag_options = options.map { |k, v| %(#{k}="#{v}") }.join(" ")
-        %(<link rel="stylesheet" href="#{href}"#{" #{tag_options}" unless tag_options.empty?}>).html_safe
+        safe_string(%(<link rel="stylesheet" href="#{href}"#{" #{tag_options}" unless tag_options.empty?}>))
       end
     end
 
@@ -486,9 +564,21 @@ module StyleCapsule
       # Construct HTML manually to avoid any HTML escaping issues
       # CSS content should not be HTML-escaped as it's inside a <style> tag
       # Using string interpolation with html_safe ensures CSS is not escaped
-      %(<style type="text/css">#{css_content}</style>).html_safe
+      safe_string(%(<style type="text/css">#{css_content}</style>))
+    end
+
+    # Make string HTML-safe (compatible with Rails and non-Rails)
+    #
+    # @param string [String] String to mark as safe
+    # @return [String] HTML-safe string
+    def self.safe_string(string)
+      if string.respond_to?(:html_safe)
+        string.html_safe
+      else
+        string
+      end
     end
 
-    private_class_method :render_file_stylesheet, :render_inline_stylesheet
+    private_class_method :render_file_stylesheet, :render_inline_stylesheet, :safe_string
   end
 end

data/lib/style_capsule/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StyleCapsule
-  VERSION = "1.0.2"
+  VERSION = "1.2.0"
 end

data/lib/style_capsule/view_component.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "digest/sha1"
-require "active_support/core_ext/string"
+# ActiveSupport string extensions are conditionally required in lib/style_capsule.rb
 
 module StyleCapsule
   # ViewComponent component concern for encapsulated CSS
@@ -89,6 +89,9 @@ module StyleCapsule
 
       # Use prepend to wrap call method
       base.prepend(CallWrapper)
+
+      # Register class for Rails-friendly tracking
+      ClassRegistry.register(base)
     end
 
     module ClassMethods

data/lib/style_capsule/view_component_helper.rb

@@ -36,18 +36,22 @@ module StyleCapsule
       StyleCapsule::StylesheetRegistry.register(file_path, namespace: namespace, **options)
     end
 
-    # Render StyleCapsule registered stylesheets (similar to javascript_importmap_tags)
+    # Render StyleCapsule registered stylesheets
     #
     # Usage in ViewComponent layouts:
     #   def call
-    #     helpers.stylesheet_registrymap_tags
-    #     helpers.stylesheet_registrymap_tags(namespace: :admin)
+    #     helpers.stylesheet_registry_tags
+    #     helpers.stylesheet_registry_tags(namespace: :admin)
     #   end
     #
     # @param namespace [Symbol, String, nil] Optional namespace to render (nil/blank renders all)
     # @return [String] HTML-safe string with stylesheet tags
-    def stylesheet_registrymap_tags(namespace: nil)
+    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

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 require "digest/sha1"
-require "active_support/core_ext/string"
+# Conditionally require ActiveSupport string extensions if available
+# For non-Rails usage, these are optional
+# Check first to avoid exception handling overhead in common case (Rails apps)
+unless defined?(ActiveSupport) || String.method_defined?(:html_safe)
+  begin
+    require "active_support/core_ext/string"
+  rescue LoadError
+    # ActiveSupport not available - core functionality still works
+  end
+end
 
 # StyleCapsule provides attribute-based CSS scoping for component encapsulation
 # in Phlex components, ViewComponent components, and ERB templates.
@@ -55,8 +64,8 @@ require "active_support/core_ext/string"
 #     <div class="section">Content</div>
 #   <% end %>
 #
-#   <%= stylesheet_registrymap_tags %>
-#   <%= stylesheet_registrymap_tags(namespace: :admin) %>
+#   <%= stylesheet_registry_tags %>
+#   <%= stylesheet_registry_tags(namespace: :admin) %>
 #
 # @example Namespace Support
 #   # Register stylesheets with namespaces
@@ -64,10 +73,10 @@ require "active_support/core_ext/string"
 #   StyleCapsule::StylesheetRegistry.register('stylesheets/user/profile', namespace: :user)
 #
 #   # Render all namespaces (default)
-#   <%= stylesheet_registrymap_tags %>
+#   <%= stylesheet_registry_tags %>
 #
 #   # Render specific namespace
-#   <%= stylesheet_registrymap_tags(namespace: :admin) %>
+#   <%= stylesheet_registry_tags(namespace: :admin) %>
 #
 # @example File-Based Caching (HTTP Caching)
 #   class MyComponent < ApplicationComponent
@@ -83,11 +92,14 @@ module StyleCapsule
   require_relative "style_capsule/css_processor"
   require_relative "style_capsule/css_file_writer"
   require_relative "style_capsule/stylesheet_registry"
+  require_relative "style_capsule/class_registry"
   require_relative "style_capsule/component_styles_support"
   require_relative "style_capsule/component"
+  require_relative "style_capsule/standalone_helper"
   require_relative "style_capsule/helper"
   require_relative "style_capsule/phlex_helper"
   require_relative "style_capsule/view_component"
   require_relative "style_capsule/view_component_helper"
+  require_relative "style_capsule/component_builder"
   require_relative "style_capsule/railtie" if defined?(Rails) && defined?(Rails::Railtie)
 end

data/lib/tasks/style_capsule.rake

@@ -3,76 +3,9 @@
 namespace :style_capsule do
   desc "Build StyleCapsule CSS files from components (similar to Tailwind CSS build)"
   task build: :environment do
-    require "style_capsule/css_file_writer"
-
-    # Ensure output directory exists
-    StyleCapsule::CssFileWriter.ensure_output_directory
-
-    # Collect all component classes that use StyleCapsule
-    component_classes = []
-
-    # Find Phlex components
-    if defined?(Phlex::HTML)
-      ObjectSpace.each_object(Class) do |klass|
-        if klass < Phlex::HTML && klass.included_modules.include?(StyleCapsule::Component)
-          component_classes << klass
-        end
-      end
-    end
-
-    # Find ViewComponent components
-    # Wrap in begin/rescue to handle ViewComponent loading errors (e.g., version compatibility issues)
-    begin
-      if defined?(ViewComponent::Base)
-        ObjectSpace.each_object(Class) do |klass|
-          if klass < ViewComponent::Base && klass.included_modules.include?(StyleCapsule::ViewComponent)
-            component_classes << klass
-          end
-        rescue
-          # Skip this class if checking inheritance triggers ViewComponent loading errors
-          # (e.g., ViewComponent 2.83.0 has a bug with Gem::Version#to_f)
-          next
-        end
-      end
-    rescue
-      # ViewComponent may have loading issues (e.g., version compatibility)
-      # Silently skip ViewComponent components if there's an error
-      # This allows the rake task to continue with Phlex components
-    end
-
-    # Generate CSS files for each component
-    component_classes.each do |component_class|
-      next unless component_class.inline_cache_strategy == :file
-      # Check for class method component_styles (required for file caching)
-      next unless component_class.respond_to?(:component_styles, false)
-
-      begin
-        # Use class method component_styles for file caching
-        css_content = component_class.component_styles
-        next if css_content.nil? || css_content.to_s.strip.empty?
-
-        # Create a temporary instance to get capsule
-        # Some components might require arguments, so we catch errors
-        instance = component_class.new
-        capsule_id = instance.component_capsule
-        scoped_css = instance.send(:scope_css, css_content)
-
-        # Write CSS file
-        file_path = StyleCapsule::CssFileWriter.write_css(
-          css_content: scoped_css,
-          component_class: component_class,
-          capsule_id: capsule_id
-        )
-
-        puts "Generated: #{file_path}" if file_path
-      rescue ArgumentError, NoMethodError => e
-        # Component requires arguments or has dependencies - skip it
-        puts "Skipped #{component_class.name}: #{e.message}"
-        next
-      end
-    end
+    require "style_capsule/component_builder"
 
-    puts "StyleCapsule CSS files built successfully"
+    StyleCapsule::ComponentBuilder.build_all(output_proc: ->(msg) { puts msg })
   end
 
   desc "Clear StyleCapsule generated CSS files"

data/sig/style_capsule.rbs

@@ -88,7 +88,8 @@ module StyleCapsule
 
   module ViewComponentHelper
     def register_stylesheet: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
-    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> String
+    def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> String
+    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> String  # deprecated
   end
 
   module Helper
@@ -96,12 +97,14 @@ module StyleCapsule
     def scope_css: (String css_content, String capsule_id) -> String
     def style_capsule: (?String css_content, ?capsule_id: String | nil) { () -> String } -> String
     def register_stylesheet: (String file_path, ?namespace: Symbol | String | nil, **Hash[untyped, untyped] options) -> void
-    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> String
+    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_registrymap_tags: (?namespace: Symbol | String | nil) -> void
+    def stylesheet_registry_tags: (?namespace: Symbol | String | nil) -> void
+    def stylesheet_registrymap_tags: (?namespace: Symbol | String | nil) -> void  # deprecated
   end
 
   class Railtie < Rails::Railtie