vident-phlex 0.13.0 → 1.0.0.alpha1

data/README.md

@@ -1,866 +1,707 @@
 # Vident
 
-Vident is a collection of gems that provide a set of tools for building web applications with Ruby on Rails.
+A powerful Ruby gem for building interactive, type-safe components in Rails applications with seamless [Stimulus.js](https://stimulus.hotwired.dev/) integration. 
 
-## Included Gems
+Vident supports both [ViewComponent](https://viewcomponent.org/) and [Phlex](https://www.phlex.fun/) rendering engines while providing a consistent API for creating 
+reusable UI components powered by [Stimulus.js](https://stimulus.hotwired.dev/).
 
-- `vident`: The core Vident library
-- `vident-better_html`: Better HTML integration for Vident
-- `vident-phlex`: Phlex integration for Vident
-- `vident-tailwind`: Tailwind CSS integration for Vident
-- `vident-typed`: Type system for Vident components
-- `vident-typed-minitest`: Minitest integration for typed Vident components
-- `vident-typed-phlex`: Phlex integration for typed Vident components
-- `vident-typed-view_component`: ViewComponent integration for typed Vident
-- `vident-view_component`: ViewComponent integration for Vident
-- `vident-view_component-caching`: Caching support for Vident ViewComponents
+## Table of Contents
 
-## Directory Structure
+- [Introduction](#introduction)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Core Concepts](#core-concepts)
+- [Component DSL](#component-dsl)
+- [Stimulus Integration](#stimulus-integration)
+- [Advanced Features](#advanced-features)
+- [Testing](#testing)
+- [Contributing](#contributing)
 
-The repository is structured like this:
+## Introduction
 
-```
-vident/
-├── lib/                       # All gem code
-│   ├── vident.rb              # Core entry point
-│   ├── vident-phlex.rb        # Gem entry points
-│   ├── vident-better_html.rb
-│   ├── vident/                # Shared code
-│       ├── base.rb
-│       ├── phlex/             # Phlex integration
-│       ├── better_html/       # Better HTML integration
-│       └── ...
-├── test/                      # All tests
-│   ├── vident/                # Core tests
-│   ├── vident-phlex/          # Tests for each gem
-│   └── ...
-├── docs/                      # Documentation
-├── examples/                  # Examples
-├── vident.gemspec            # Gemspec for core gem
-├── vident-phlex.gemspec      # Gemspecs for each gem
-└── ...
-```
-
-## Development
-
-### Setting Up Development Environment
+Vident is a collection of gems that enhance Rails view components with:
 
-```bash
-# Clone the repository
-git clone https://github.com/stevegeek/vident.git
-cd vident
+- **Type-safe properties** using the Literal gem
+- **First-class [Stimulus.js](https://stimulus.hotwired.dev/) integration** for interactive behaviors
+- **Support for both [ViewComponent](https://viewcomponent.org/) and [Phlex](https://www.phlex.fun/)** rendering engines
+- **Intelligent CSS class management** with built-in Tailwind CSS merging
+- **Component caching** for improved performance
+- **Declarative DSL** for clean, maintainable component code
 
-# Install dependencies
-bundle install
-```
+### Why Vident?
 
-### Running Tests
+Stimulus.js is a powerful framework for adding interactivity to HTML, but managing the data attributes can be cumbersome,
+and refactoring can be error-prone (as say controller names are repeated in many places).
 
-To run tests for all gems:
+Vident simplifies this by providing a declarative DSL for defining Stimulus controllers, actions, targets, and values
+directly within your component classes so you don't need to manually craft data attributes in your templates.
 
-```bash
-rake test
-```
+Vident also ensures that your components are flexible: for example you can easily add to, or override configuration,
+classes etc at the point of rendering.
 
-To run tests for a specific gem:
+Vident's goal is to make building UI components more maintainable, and remove some of the boilerplate code of Stimulus 
+without being over-bearing or including too much magic.
 
-```bash
-rake test:vident-phlex
-```
+## Installation
 
-### Building and Installing Gems
+Add the core gem and your preferred rendering engine integration to your Gemfile:
 
-To build all gems:
+```ruby
+# Core gem (required)
+gem "vident"
 
-```bash
-rake build
+# Choose your rendering engine (at least one required)
+gem "vident-view_component"  # For ViewComponent support
+gem "vident-phlex"           # For Phlex support
 ```
 
-To install all gems locally:
+Then run:
 
 ```bash
-rake install
+bundle install
 ```
 
-## Contributing
-
-1. Fork the repository
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
-
-## License
+## Quick Start
 
-The gems are available as open source under the terms of the [MIT License](LICENSE.txt).
+Here's a simple example of a Vident component using ViewComponent:
 
----
-
-# Component Documentation
-
-## gem: vident-better_html
-
-# Vident::BetterHtml
-Short description and motivation.
+```ruby
+# app/components/button_component.rb
+class ButtonComponent < Vident::ViewComponent::Base
+  # Define typed properties
+  prop :text, String, default: "Click me"
+  prop :url, _Nilable(String)
+  prop :style, Symbol, in: [:primary, :secondary], default: :primary
+  prop :clicked_count, Integer, default: 0
+  
+  # Configure Stimulus integration
+  stimulus do
+    actions [:click, :handle_click]
+    # Static values
+    values loading_duration: 1000
+    # Map the clicked_count prop as a Stimulus value
+    values_from_props :clicked_count
+    # Dynamic values using procs (evaluated in component context)
+    values item_count: -> { @items.count }
+    values api_url: -> { Rails.application.routes.url_helpers.api_items_path }
+    # Static and dynamic classes
+    classes loading: "opacity-50 cursor-wait"
+    classes size: -> { @items.count > 10 ? "large" : "small" }
+  end
 
-### Usage
-How to use my plugin.
+  def call
+    root_element do
+      @text
+    end
+  end
 
-```ruby
-BetterHtml.config = BetterHtml::Config.new(YAML.load(File.read(".better-html.yml")))
+  private
 
-BetterHtml.configure do |config|
-  config.template_exclusion_filter = proc { |filename| !filename.start_with?(Rails.root.to_s) }
-end
-# ViewComponent needs to do this hack to work in certain cases
-# see https://github.com/Shopify/better-html/pull/98
-class BetterHtml::HtmlAttributes
-  alias_method :to_s_without_html_safe, :to_s
+  def root_element_attributes
+    {
+      element_tag: @url ? :a : :button,
+      html_options: { href: @url }.compact
+    }
+  end
 
-  def to_s
-    to_s_without_html_safe.html_safe
+  def element_classes
+    base_classes = "btn"
+    case @style
+    when :primary
+      "#{base_classes} btn-primary"
+    when :secondary
+      "#{base_classes} btn-secondary"
+    end
   end
 end
 ```
 
-### Installation
-Add this line to your application's Gemfile:
 
-```ruby
-gem "vident-better_html"
-```
+Add the corresponding Stimulus controller would be:
 
-And then execute:
-```bash
-$ bundle
-```
+```javascript
+// app/javascript/controllers/button_component_controller.js
+// Can also be "side-car" in the same directory as the component, see the documentation for details
+import { Controller } from "@hotwired/stimulus"
 
-Or install it yourself as:
-```bash
-$ gem install vident-better_html
+export default class extends Controller {
+  static values = { 
+    clickedCount: Number, 
+    loadingDuration: Number 
+  }
+  static classes = ["loading"]
+  
+  handleClick(event) {
+    // Increment counter
+    this.clickedCountValue++
+    
+    // Add loading state
+    this.element.classList.add(this.loadingClass)
+    this.element.disabled = true
+    
+    // Use the loading duration from the component
+    setTimeout(() => {
+      this.element.classList.remove(this.loadingClass)
+      this.element.disabled = false
+      
+      // Update text to show count
+      this.element.textContent = `${this.element.textContent} (${this.clickedCountValue})`
+    }, this.loadingDurationValue)
+  }
+}
 ```
 
----
+Use the component in your views:
 
-## gem: vident-phlex
+```erb
+<!-- Default clicked count of 0 -->
+<%= render ButtonComponent.new(text: "Save", style: :primary) %>
 
-# Vident::Phlex
+<!-- Pre-set clicked count -->
+<%= render ButtonComponent.new(text: "Submit", style: :primary, clicked_count: 5) %>
 
-[Phlex](https://phlex.fun/) powered [Vident](https://github.com/stevegeek/vident) components.
+<!-- Link variant -->
+<%= render ButtonComponent.new(text: "Cancel", url: "/home", style: :secondary) %>
 
-```ruby
-class ApplicationComponent < ::Vident::Phlex::HTML
-end
+<!-- Override things -->
+<%= render ButtonComponent.new(text: "Cancel", url: "/home" classes: "bg-red-900", html_options: {role: "button"}) %>
 ```
 
-For more details see [vident](https://github.com/stevegeek/vident).
-
-### Usage
-How to use my plugin.
+The rendered HTML includes all Stimulus data attributes:
 
-### Installation
-Add this line to your application's Gemfile:
+```html
+<!-- First button with default count -->
+<button class="bg-blue-500 hover:bg-blue-700 text-white" 
+        data-controller="button-component" 
+        data-action="click->button-component#handleClick"
+        data-button-component-clicked-count-value="0"
+        data-button-component-loading-duration-value="1000"
+        data-button-component-loading-class="opacity-50 cursor-wait"
+        id="button-component-123">
+  Save
+</button>
+
+<!-- Second button with pre-set count -->
+<button class="bg-blue-500 hover:bg-blue-700 text-white" 
+        data-controller="button-component" 
+        data-action="click->button-component#handleClick"
+        data-button-component-clicked-count-value="5"
+        data-button-component-loading-duration-value="1000"
+        data-button-component-loading-class="opacity-50 cursor-wait"
+        id="button-component-456">
+  Submit
+</button>
+```
+
+## Core Concepts
+
+### Component Properties
+
+Vident uses the Literal gem to provide type-safe component properties:
 
 ```ruby
-gem "vident-phlex"
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install vident-phlex
+class CardComponent < Vident::ViewComponent::Base
+  # Basic property with type
+  prop :title, String
+  
+  # Property with default value
+  prop :subtitle, String, default: ""
+  
+  # Nullable property
+  prop :image_url, _Nilable(String)
+  
+  # Property with validation
+  prop :size, _Union(:small, :medium, :large), default: :medium
+  
+  # Boolean property (creates predicate method)
+  prop :featured, _Boolean, default: false
+end
 ```
 
----
+### Built-in Properties
 
-## gem: vident-tailwind
+Every Vident component includes these properties:
 
-# Vident::Tailwind
-Short description and motivation.
+- `element_tag` - The HTML tag for the root element (default: `:div`)
+- `id` - The component's DOM ID (auto-generated if not provided)
+- `classes` - Additional CSS classes
+- `html_options` - Hash of HTML attributes
 
-### Usage
-How to use my plugin.
+### Root Element Rendering
 
-### Installation
-Add this line to your application's Gemfile:
+The `root_element` helper method renders your component's root element with all configured attributes:
 
 ```ruby
-gem "vident-tailwind"
-```
+# In your component class
+def element_classes
+  ["card", featured? ? "card-featured" : nil]
+end
 
-And then execute:
-```bash
-$ bundle
-```
+private
 
-Or install it yourself as:
-```bash
-$ gem install vident-tailwind
+def root_element_attributes
+  {
+    html_options: { role: "article", "aria-label": title }
+  }
+end
 ```
 
----
+```erb
+<%# In your template %>
+<%= root_element do %>
+  <h2><%= title %></h2>
+  <p><%= subtitle %></p>
+<% end %>
+```
 
-## gem: vident-typed-minitest
+## Component DSL
 
-# Vident::Typed::Minitest
-Short description and motivation.
+### ViewComponent Integration
 
-### Usage
-How to use my plugin.
+```ruby
+class MyComponent < Vident::ViewComponent::Base
+  # Component code
+end
 
-### Installation
-Add this line to your application's Gemfile:
+# Or with an application base class
+class ApplicationComponent < Vident::ViewComponent::Base
+  # Shared configuration
+end
 
-```ruby
-gem "vident-typed-minitest"
+class MyComponent < ApplicationComponent
+  # Component code
+end
 ```
 
-And then execute:
-```bash
-$ bundle
-```
+### Phlex Integration
 
-Or install it yourself as:
-```bash
-$ gem install vident-typed-minitest
+```ruby
+class MyComponent < Vident::Phlex::HTML
+  def view_template
+    root do
+      h1 { "Hello from Phlex!" }
+    end
+  end
+end
 ```
 
----
+## Stimulus Integration
 
-## gem: vident-typed-phlex
+Vident provides comprehensive Stimulus.js integration to add interactivity to your components.
 
-# Vident::Typed::Phlex
+### Declarative Stimulus DSL
 
-Adds typed attributes to Vident Phlex based components.
+Use the `stimulus` block for clean, declarative configuration:
 
 ```ruby
-class ApplicationComponent < ::Vident::Typed::Phlex::HTML
+class ToggleComponent < Vident::ViewComponent::Base
+  prop :expanded, _Boolean, default: false
+  
+  stimulus do
+    # Define actions the controller responds to
+    actions :toggle, :expand, :collapse
+    
+    # Define targets for DOM element references
+    targets :button, :content
+    
+    # Define static values
+    values animation_duration: 300
+    
+    # Define dynamic values using procs (evaluated in component context)
+    values item_count: -> { @items.count }
+    values current_state: proc { expanded? ? "open" : "closed" }
+    
+    # Map values from component props
+    values_from_props :expanded
+    
+    # Define CSS classes for different states
+    classes expanded: "block",
+            collapsed: "hidden",
+            transitioning: "opacity-50"
+  end
 end
 ```
 
-For more details see [vident](https://github.com/stevegeek/vident).
-
-### Usage
-How to use my plugin.
+### Dynamic Values and Classes with Procs
 
-### Installation
-Add this line to your application's Gemfile:
+The Stimulus DSL supports dynamic values and classes using procs or lambdas that are evaluated in the component instance context:
 
 ```ruby
-gem "vident-typed-phlex"
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install vident-typed-phlex
+class DynamicComponent < Vident::ViewComponent::Base
+  prop :items, _Array(Hash), default: -> { [] }
+  prop :loading, _Boolean, default: false
+  prop :user, _Nilable(User)
+  
+  stimulus do
+    # Mix static and dynamic values in a single call
+    values(
+      static_config: "always_same",
+      item_count: -> { @items.count },
+      loading_state: proc { @loading ? "loading" : "idle" },
+      user_role: -> { @user&.role || "guest" },
+      api_endpoint: -> { Rails.application.routes.url_helpers.api_items_path }
+    )
+    
+    # Mix static and dynamic classes
+    classes(
+      base: "component-container",
+      loading: -> { @loading ? "opacity-50 cursor-wait" : "" },
+      size: proc { @items.count > 10 ? "large" : "small" },
+      theme: -> { current_user&.dark_mode? ? "dark" : "light" }
+    )
+    
+    # Dynamic actions and targets
+    actions -> { @loading ? [] : [:click, :submit] }
+    targets -> { @expanded ? [:content, :toggle] : [:toggle] }
+  end
+  
+  private
+  
+  def current_user
+    @current_user ||= User.current
+  end
+end
 ```
 
----
-
-## gem: vident-typed-view_component
-
-# Vident::Typed::ViewComponent
+Procs have access to instance variables, component methods, and Rails helpers.
 
-Adds typed attributes to Vident ViewComponent components.
+**Important**: Each proc returns a single value for its corresponding stimulus attribute. If a proc returns an array, that entire array is treated as a single value, not multiple separate values. To provide multiple values for an attribute, use multiple procs or mix procs with static values:
 
 ```ruby
-class ApplicationComponent < ::Vident::Typed::ViewComponent::Base
+stimulus do
+  # Single proc returns a single value (even if it's an array)
+  actions -> { @expanded ? [:click, :submit] : :click }
+  
+  # Multiple procs provide multiple values
+  actions -> { @can_edit ? :edit : nil },
+          -> { @can_delete ? :delete : nil },
+          :cancel  # static value
+  
+  # This results in: [:edit, :delete, :cancel] (assuming both conditions are true)
 end
 ```
 
-For more details see [vident](https://github.com/stevegeek/vident).
-
-### Examples
+### Scoped Custom Events
 
-Before we dive into a specific example note that there are some components implemented in `test/dummy/app/components`.
+Vident provides helper methods to generate scoped event names for dispatching custom events that are unique to your component:
 
-Try them out by starting Rails:
+```ruby
+class MyComponent < Vident::ViewComponent::Base
+  stimulus do
+    # Define an action that responds to a scoped event
+    actions [stimulus_scoped_event_on_window(:data_loaded), :handle_data_loaded]
+  end
+  
+  def handle_click
+    # Dispatch a scoped event from JavaScript
+    # This would generate: "my-component:dataLoaded"
+    puts stimulus_scoped_event(:data_loaded)
+    
+    # For window events, this generates: "my-component:dataLoaded@window" 
+    puts stimulus_scoped_event_on_window(:data_loaded)
+  end
+end
 
-```bash
-cd test/dummy
-bundle install
-rails assets:precompile
-rails s
+# Available as both class and instance methods:
+MyComponent.stimulus_scoped_event(:data_loaded)      # => "my-component:dataLoaded"
+MyComponent.new.stimulus_scoped_event(:data_loaded)  # => "my-component:dataLoaded"
 ```
 
-and visiting http://localhost:3000
-
-
-### A Vident component example (without Stimulus)
-
-First is an example component that uses `Vident::Typed::ViewComponent::Base` but no Stimulus features.
+This is useful for:
+- Dispatching events from Stimulus controllers to communicate between components
+- Creating unique event names that won't conflict with other components
+- Setting up window-level event listeners with scoped names
 
-It is an avatar component that can either be displayed as an image or as initials.
+### Manual Stimulus Configuration
 
-It supports numerous sizes and shapes and can optionally have a border. It also generates a cache key for use in fragment caching or etag generation.
+For more control, configure Stimulus attributes manually:
 
 ```ruby
-class AvatarComponent < ::Vident::Typed::ViewComponent::Base
-  include ::Vident::Tailwind
-  include ::Vident::Caching
-
-  no_stimulus_controller
-  with_cache_key :attributes
-
-  attribute :url, String, allow_nil: true, allow_blank: false
-  attribute :initials, String, allow_blank: false
-
-  attribute :shape, Symbol, in: %i[circle square], default: :circle
-
-  attribute :border, :boolean, default: false
-
-  attribute :size, Symbol, in: %i[tiny small normal medium large x_large xx_large], default: :normal
-
+class CustomComponent < Vident::ViewComponent::Base
   private
-
-  def default_html_options
-    if image_avatar?
-      { class: "inline-block object-contain", src: url, alt: t(".image") }
-    else
-      { class: "inline-flex items-center justify-center bg-gray-500" }
-    end
-  end
-
-  def element_classes
-    [size_classes, shape_class, border? ? "border" : ""]
-  end
-
-  alias_method :image_avatar?, :url?
-
-  def shape_class
-    (shape == :circle) ? "rounded-full" : "rounded-md"
-  end
-
-  def size_classes
-    case size
-    when :tiny
-      "w-6 h-6"
-    when :small
-      "w-8 h-8"
-    when :medium
-      "w-12 h-12"
-    when :large
-      "w-14 h-14"
-    when :x_large
-      "sm:w-24 sm:h-24 w-16 h-16"
-    when :xx_large
-      "sm:w-32 sm:h-32 w-24 h-24"
-    else
-      "w-10 h-10"
-    end
-  end
-
-  def text_size_class
-    case size
-    when :tiny
-      "text-xs"
-    when :small
-      "text-xs"
-    when :medium
-      "text-lg"
-    when :large
-      "sm:text-xl text-lg"
-    when :extra_large
-      "sm:text-2xl text-xl"
-    else
-      "text-medium"
-    end
+  
+  def root_element_attributes
+    {
+      element_tag: :article,
+      stimulus_controllers: ["custom", "analytics"],
+      stimulus_actions: [
+        [:click, :handleClick],
+        [:custom_event, :handleCustom]
+      ],
+      stimulus_values: {
+        endpoint: "/api/data",
+        refresh_interval: 5000
+      },
+      stimulus_targets: {
+        container: true
+      }
+    }
   end
 end
 ```
 
-```erb
-<%= render root(
-             element_tag: image_avatar? ? :img : :div,
-             html_options: default_html_options
-           ) do %>
-  <% unless image_avatar? %>
-    <span class="<%= text_size_class %> font-medium leading-none text-white"><%= initials %></span>
-  <% end %>
-<% end %>
-
-```
-
-Example usages:
+or you can use tag helpers to generate HTML with Stimulus attributes:
 
 ```erb
-<!-- These will render -->
-<%= render AvatarComponent.new(url: "https://someurl.com/avatar.jpg", initials: "AB" size: :large) %>
-<%= render AvatarComponent.new(url: "https://someurl.com/avatar.jpg", html_options: {alt: "My alt text", class: "object-scale-down"}) %>
-<%= render AvatarComponent.new(initials: "SG", size: :small) %>
-<%= render AvatarComponent.new(initials: "SG", size: :large, html_options: {class: "border-2 border-red-600"}) %>
-
-<!-- These will raise an error -->
-<!-- missing initals -->
-<%= render AvatarComponent.new(url: "https://someurl.com/avatar.jpg", size: :large) %> 
-<!-- initials blank -->
-<%= render AvatarComponent.new(initials: "", size: :large) %> 
- <!-- invalid size -->
-<%= render AvatarComponent.new(initials: "SG", size: :foo_bar) %>
-```
-
+  <%= content_tag(:input, type: "text", class: "...", data: {**greeter.stimulus_target(:name)}) %>
+  <%= content_tag(:button, @cta, class: "...", data: {**greeter.stimulus_action([:click, :greet])}) do %>
+    <%= @cta %>
+  <% end %>
+  <%= content_tag(:span, class: "...", data: {**greeter.stimulus_target(:output)}) %>
 
-The following is rendered when used `render AvatarComponent.new(initials: "SG", size: :small, border: true)`:
+  <%# OR use the vident tag helper  %>
 
-```html
-<div class="avatar-component w-8 h-8 rounded-full border inline-flex items-center justify-center bg-gray-500" id="avatar-component-9790427-12">
-  <span class="text-xs font-medium leading-none text-white">SG</span>
-</div>
+  <%= greeter.tag(:input, stimulus_target: :name, type: "text", class: "...") %>
+  <%= greeter.tag(:button, stimulus_action: [:click, :greet], class: "...") do %>
+    <%= @cta %>
+  <% end %>
+  <%= greeter.tag(:span, stimulus_target: :output, class: "...") %>
 ```
 
-The following is rendered when used `render AvatarComponent.new(url: "https://i.pravatar.cc/300", initials: "AB", html_options: {alt: "My alt text", class: "block"})`:
+or in your Phlex templates:
 
-```html
-<img src="https://i.pravatar.cc/300" alt="My alt text" class="avatar-component w-10 h-10 rounded-full object-contain block" id="avatar-component-7083941-11">
+```ruby
+root_element do |greeter|
+  input(type: "text", data: {**greeter.stimulus_target(:name)}, class: %(...))
+  trigger_or_default(greeter)
+  greeter.tag(:span, stimulus_target: :output, class: "ml-4 #{greeter.class_list_for_stimulus_classes(:pre_click)}") do
+    plain %( ... )
+  end
+end
 ```
 
-----
-
-![Example](examples/avatar.png)
-
-
-### Another ViewComponent + Vident example with Stimulus
-
-Consider the following ERB that might be part of an application's views. The app uses `ViewComponent`, `Stimulus` and `Vident`.
-
-The Greeter is a component that displays a text input and a button. When the button is clicked, the text input's value is
-used to greet the user. At the same time the button changes to be a 'reset' button, which resets the greeting when clicked again.
-
-![ex1.gif](examples/ex1.gif)
+or directly in the ViewComponent template (eg with ERB) using the `as_stimulus_*` helpers
 
 ```erb
-<%# app/views/home/index.html.erb %>
-
-<!-- ... -->
-
-<!-- render the Greeter ViewComponent (that uses Vident) -->
-<%= render ::GreeterComponent.new(cta: "Hey!", html_options: {class: "my-4"}) do |greeter| %>
-  <%# this component has a slot called `trigger` that renders a `ButtonComponent` (which also uses Vident) %> 
-  <% greeter.with_trigger(
-       
-       # The button component has attributes that are typed
-       before_clicked: "Greet",
-       after_clicked: "Greeted! Reset?",
-       
-       # A stimulus action is added to the button that triggers the `greet` action on the greeter stimulus controller.
-       # This action will be added to any defined on the button component itself
-       actions: [
-         greeter.action(:click, :greet),
-       ],
-       
-       # We can also override the default button classes of our component, or set other HTML attributes
-       html_options: {
-         class: "bg-red-500 hover:bg-red-700"
-       }
-     ) %>
-<% end %>
-
-<!-- ... -->
-```
-
-The output HTML of the above, using Vident, is:
-
-```html 
-<div class="greeter-component py-2 my-4" 
-     data-controller="greeter-component" 
-     data-greeter-component-pre-click-class="text-md text-gray-500" 
-     data-greeter-component-post-click-class="text-xl text-blue-700" 
-     id="greeter-component-1599855-6">
-  <input type="text" 
-         data-greeter-component-target="name" 
-         class="shadow appearance-none border rounded py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline">
-  <button class="button-component ml-4 whitespace-no-wrap bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded bg-red-500 hover:bg-red-700" 
-          data-controller="button-component" 
-          data-action="click->greeter-component#greet button-component#changeMessage" 
-          data-button-component-after-clicked-message="Greeted! Reset?" 
-          data-button-component-before-clicked-message="Greet" 
-          id="button-component-7799479-7">Hey!</button>
-  <!-- you can also use the `target_tag` helper to render targets -->
-  <span class="ml-4 text-md text-gray-500" 
-        data-greeter-component-target="output">
-    ...
-  </span>
-</div>
+  <%# HTML embellishment approach, most familiar to working with HTML in ERB, but is injecting directly into open HTML tags... %>
+  <input type="text"
+         <%= greeter.as_stimulus_targets(:name) %>
+         class="...">
+  <button <%= greeter.as_stimulus_actions([:click, :greet]) %>
+          class="...">
+    <%= @cta %>
+  </button>
+  <span <%= greeter.as_stimulus_targets(:output) %> class="..."></span>
 ```
 
-Let's look at the components in more detail.
 
-The main component is the `GreeterComponent`:
-
-```ruby
-# app/components/greeter_component.rb
+### Stimulus Helpers in Templates
 
-class GreeterComponent < ::Vident::ViewComponent::Base
-  renders_one :trigger, ButtonComponent
-end
-```
+Vident provides helper methods for generating Stimulus attributes:
 
 ```erb
-<%# app/components/greeter_component.html.erb %>
-
-<%# Rendering the `root` element creates a tag which has stimulus `data-*`s, a unique id & other attributes set. %>
-<%# The stimulus controller name (identifier) is derived from the component name, and then used to generate the relavent data attribute names. %>
-
-<%= render root named_classes: {
-  pre_click: "text-md text-gray-500", # named classes are exposed to Stimulus as `data-<controller>-<n>-class` attributes
-  post_click: "text-xl text-blue-700",
-  html_options: {class: "py-2"}
-} do |greeter| %>
-
-  <%# `greeter` is the root element and exposes methods to generate stimulus targets and actions %>
-  <input type="text"
-         <%= greeter.as_target(:name) %>
-         class="shadow appearance-none border rounded py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline">
+<%= render root do |component| %>
+  <!-- Create a target -->
+  <div <%= component.as_target(:content) %>>
+    Content here
+  </div>
   
-  <%# Render the slot %>
-  <%= trigger %>
+  <!-- Create an action -->
+  <button <%= component.as_action(:click, :toggle) %>>
+    Toggle
+  </button>
   
-  <%# you can also use the `target_tag` helper to render targets %>
-  <%= greeter.target_tag(
-        :span, 
-        :output, 
-        # Stimulus named classes can be referenced to set class attributes at render time
-        class: "ml-4 #{greeter.named_classes(:pre_click)}" 
-      ) do %>
-    ...
+  <!-- Use the tag helper -->
+  <%= component.tag :div, stimulus_target: :output, class: "mt-4" do %>
+    Output here
   <% end %>
+  
+  <!-- Multiple targets/actions -->
+  <input <%= component.as_targets(:input, :field) %> 
+         <%= component.as_actions([:input, :validate], [:change, :save]) %>>
 <% end %>
-
 ```
 
-```js
-// app/components/greeter_component_controller.js
+### Stimulus Outlets
 
-import { Controller } from "@hotwired/stimulus"
+Connect components via Stimulus outlets:
 
-// This is a Stimulus controller that is automatically registered for the `GreeterComponent`
-// and is 'sidecar' to the component. You can see that while in the ERB we use Ruby naming conventions
-// with snake_case Symbols, here they are converted to camelCase names. We can also just use camelCase 
-// in the ERB if we want.
-export default class extends Controller {
-  static targets = [ "name", "output" ]
-  static classes = [ "preClick", "postClick" ]
-
-  greet() {
-    this.clicked = !this.clicked;
-    this.outputTarget.classList.toggle(this.preClickClasses, !this.clicked);
-    this.outputTarget.classList.toggle(this.postClickClasses, this.clicked);
-
-    if (this.clicked)
-      this.outputTarget.textContent = `Hello, ${this.nameTarget.value}!`
-    else
-      this.clear();
-  }
 
-  clear() {
-    this.outputTarget.textContent = '...';
-    this.nameTarget.value = '';
-  }
-}
-```
 
-The slot renders a `ButtonComponent` component:
 
-```ruby
-# app/components/button_component.rb
+### Stimulus Controller Naming
 
-class ButtonComponent < ::Vident::Typed::ViewComponent::Base
-  # The attributes can specify an expected type, a default value and if nil is allowed.
-  attribute :after_clicked, String, default: "Greeted!"
-  attribute :before_clicked, String, allow_nil: false
+Vident automatically generates Stimulus controller names based on your component class:
 
-  # This example is a templateless ViewComponent.
-  def call
-    # The button is rendered as a <button> tag with an click action on its own controller.
-    render root(
-      element_tag: :button,
-      
-      # We can define actions as arrays of Symbols, or pass manually manually crafted strings.
-      # Here we specify the action name only, implying an action on the current components controller
-      # and the default event type of `click`.
-      actions: [:change_message],
-      # Alternatively: [:click, :change_message] or ["click", "changeMessage"] or even "click->button-component#changeMessage"
-      
-      # A couple of data values are also set which will be available to the controller
-      data_maps: [{after_clicked_message: after_clicked, before_clicked_message: before_clicked}],
-      
-      # The <button> tag has a default styling set directly on it. Note that
-      # if not using utility classes, you can style the component using its 
-      # canonical class name (which is equal to the component's stimulus identifier), 
-      # in this case `button-component`.
-      html_options: {class: "ml-4 whitespace-no-wrap bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded"}
-    ) do
-      @before_clicked
-    end
-  end
-end
-```
+- `ButtonComponent` → `button-component`
+- `Admin::UserCardComponent` → `admin--user-card-component`
+- `MyApp::WidgetComponent` → `my-app--widget-component`
 
-```js  
-// app/components/button_component_controller.js
+### Working with Child Components
 
-import { Controller } from "@hotwired/stimulus"
-
-export default class extends Controller {
-  // The action is in camelCase.
-  changeMessage() {
-    this.clicked = !this.clicked;
-    // The data attributes have their naming convention converted to camelCase.
-    this.element.textContent = this.clicked ? this.data.get("afterClickedMessage") : this.data.get("beforeClickedMessage");
-  }
-}
-
-```
-
-### Usage
-How to use my plugin.
-
-### Installation
-Add this line to your application's Gemfile:
+Setting Stimulus configuration between parent and child components:
 
 ```ruby
-gem "vident-typed-view_component"
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install vident-typed-view_component
-```
-
----
-
-## gem: vident-typed
-
-# Vident::Typed
-Short description and motivation.
-
-### Usage
-How to use my plugin.
-
-### Installation
-Add this line to your application's Gemfile:
-
-```ruby
-gem "vident-typed"
-```
-
-And then execute:
-```bash
-$ bundle
+class ParentComponent < Vident::ViewComponent::Base
+  renders_one :a_nested_component, ButtonComponent
+  
+  stimulus do
+    actions :handleTrigger
+  end
+end
 ```
 
-Or install it yourself as:
-```bash
-$ gem install vident-typed
+```erb
+<%= root_element do |parent| %>
+  <% parent.with_a_nested_component(
+    text: "Click me",
+    stimulus_actions: [
+      parent.stimulus_action(:click, :handleTrigger)
+    ]
+  ) %>
+<% end %>
 ```
 
----
-
-## gem: vident-view_component-caching
+This creates a nested component that once clicked triggers the parent components `handleTrigger` action.
 
-# Vident::ViewComponent::Caching
-Short description and motivation.
+## Other Features
 
-### Usage
-How to use my plugin.
+### Custom Element Tags
 
-### Installation
-Add this line to your application's Gemfile:
+Change the root element tag dynamically:
 
 ```ruby
-gem "vident-view_component-caching"
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install vident-view_component-caching
+class LinkOrButtonComponent < Vident::ViewComponent::Base
+  prop :url, _Nilable(String)
+  
+  private
+  
+  def root_element_attributes
+    {
+      element_tag: url? ? :a : :button,
+      html_options: {
+        href: url,
+        type: url? ? nil : "button"
+      }.compact
+    }
+  end
+end
 ```
 
----
-
-## gem: vident-view_component
+### Intelligent Class Management
 
-# Vident::ViewComponent
-
-[ViewComponent](https://viewcomponent.org/) powered [Vident](https://github.com/stevegeek/vident) components.
+Vident intelligently merges CSS classes from multiple sources:
 
 ```ruby
-class ApplicationComponent < ::Vident::ViewComponent::Base
+class StyledComponent < Vident::ViewComponent::Base
+  prop :variant, Symbol, default: :default
+  
+  private
+  
+  # Classes on the root element
+  def element_classes
+    ["base-class", variant_class]
+  end
+  
+  def variant_class
+    case @variant
+    when :primary then "text-blue-600 bg-blue-100"
+    when :danger then "text-red-600 bg-red-100"
+    else "text-gray-600 bg-gray-100"
+    end
+  end
 end
 ```
 
-For more details see [vident](https://github.com/stevegeek/vident).
-
-### Examples
-
-Before we dive into a specific example note that there are some components implemented in the `test/dummy/app/components`.
-
-Try them out by starting Rails:
-
-```bash
-cd test/dummy
-bundle install
-rails assets:precompile
-rails s
+Usage:
+```erb
+<!-- All classes are intelligently merged -->
+<%= render StyledComponent.new(
+  variant: :primary,
+  classes: "rounded-lg shadow"
+) %>
+<!-- Result: class="base-class text-blue-600 bg-blue-100 rounded-lg shadow" -->
 ```
 
-and visiting http://localhost:3000
-
-
-### A Vident component example (without Stimulus)
+### Tailwind CSS Integration
 
-First is an example component that uses `Vident::ViewComponent::Base` but no Stimulus features. 
-
-It is an avatar component that can either be displayed as an image or as initials. It supports numerous sizes and shapes and can optionally have a border. It also generates a cache key for use in fragment caching or etag generation.
+Vident includes built-in support for Tailwind CSS class merging when the `tailwind_merge` gem is available:
 
 ```ruby
-class AvatarComponent < ::Vident::ViewComponent::Base
-  include ::Vident::Tailwind
-  include ::Vident::Caching
-
-  no_stimulus_controller
-  with_cache_key :attributes
-
-  attribute :url, allow_nil: true
-  attribute :initials, allow_nil: false
-
-  attribute :shape, default: :circle
-
-  attribute :border, default: false
-
-  attribute :size, default: :normal
-
+class TailwindComponent < Vident::ViewComponent::Base
+  prop :size, Symbol, default: :medium
+  
   private
-
-  def default_html_options
-    if image_avatar?
-      { class: "inline-block object-contain", src: url, alt: t(".image") }
-    else
-      { class: "inline-flex items-center justify-center bg-gray-500" }
-    end
-  end
-
+  
   def element_classes
-    [size_classes, shape_class, border? ? "border" : ""]
+    # Conflicts with size_class will be resolved automatically
+    "p-2 text-sm #{size_class}"
   end
-
-  alias_method :image_avatar?, :url?
-
-  def shape_class
-    (shape == :circle) ? "rounded-full" : "rounded-md"
-  end
-
-  def size_classes
-    case size
-    when :tiny
-      "w-6 h-6"
-    when :small
-      "w-8 h-8"
-    when :medium
-      "w-12 h-12"
-    when :large
-      "w-14 h-14"
-    when :x_large
-      "sm:w-24 sm:h-24 w-16 h-16"
-    when :xx_large
-      "sm:w-32 sm:h-32 w-24 h-24"
-    else
-      "w-10 h-10"
+  
+  def size_class
+    case @size
+    when :small then "p-1 text-xs"
+    when :large then "p-4 text-lg"
+    else "p-2 text-base"
     end
   end
+end
+```
 
-  def text_size_class
-    case size
-    when :tiny
-      "text-xs"
-    when :small
-      "text-xs"
-    when :medium
-      "text-lg"
-    when :large
-      "sm:text-xl text-lg"
-    when :extra_large
-      "sm:text-2xl text-xl"
-    else
-      "text-medium"
-    end
-  end
+### Component Caching
+
+Enable fragment caching for expensive components:
+
+```ruby
+class ExpensiveComponent < Vident::ViewComponent::Base
+  include Vident::Caching
+  
+  with_cache_key :to_h  # Cache based on all attributes
+  # or
+  with_cache_key :id, :updated_at  # Cache based on specific attributes
 end
 ```
 
 ```erb
-<%= render root(
-             element_tag: image_avatar? ? :img : :div,
-             html_options: default_html_options
-           ) do %>
-  <% unless image_avatar? %>
-    <span class="<%= text_size_class %> font-medium leading-none text-white"><%= initials %></span>
-  <% end %>
+<% cache component.cache_key do %>
+  <%= render component %>
 <% end %>
 ```
 
-Example usages:
 
-```erb
-<%= render AvatarComponent.new(url: "https://someurl.com/avatar.jpg", initials: "AB" size: :large) %>
-<%= render AvatarComponent.new(url: "https://someurl.com/avatar.jpg", html_options: {alt: "My alt text", class: "object-scale-down"}) %>
-<%= render AvatarComponent.new(initials: "SG", size: :small) %>
-<%= render AvatarComponent.new(initials: "SG", size: :large, html_options: {class: "border-2 border-red-600"}) %>
-```
+## Testing
 
-The following is rendered when used `render AvatarComponent.new(initials: "SG", size: :small, border: true)`:
+Vident components work seamlessly with testing frameworks that support ViewComponent or Phlex.
 
-```html
-<div class="avatar-component w-8 h-8 rounded-full border inline-flex items-center justify-center bg-gray-500" id="avatar-component-9790427-12">
-  <span class="text-xs font-medium leading-none text-white">SG</span>
-</div>
+## Development
+
+### Running Tests
+
+```bash
+# Run all tests
+bin/rails test
 ```
 
-The following is rendered when used `render AvatarComponent.new(url: "https://i.pravatar.cc/300", initials: "AB", html_options: {alt: "My alt text", class: "block"})`:
+### Local Development
 
-```html
-<img src="https://i.pravatar.cc/300" alt="My alt text" class="avatar-component w-10 h-10 rounded-full object-contain block" id="avatar-component-7083941-11">
+```bash
+# Clone the repository
+git clone https://github.com/stevegeek/vident.git
+cd vident
+
+# Install dependencies
+bundle install
+
+# Run the dummy app
+cd test/dummy
+rails s
 ```
 
-----
+## Contributing
 
-![Example](examples/avatar.png)
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/my-new-feature`)
+3. Write tests for your changes
+4. Commit your changes (`git commit -am 'Add new feature'`)
+5. Push to the branch (`git push origin feature/my-new-feature`)
+6. Create a Pull Request
 
-### Usage
-How to use my plugin.
+## License
 
-### Installation
-Add this line to your application's Gemfile:
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
-```ruby
-gem "vident-view_component"
-```
+## Credits
 
-And then execute:
-```bash
-$ bundle
-```
+Vident is maintained by [Stephen Ierodiaconou](https://github.com/stevegeek).
 
-Or install it yourself as:
-```bash
-$ gem install vident-view_component
-```
+Special thanks to the ViewComponent and Phlex communities for their excellent component frameworks that Vident builds upon.