vident-view_component 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 225bfeb157d05dba1d6aa7d4dbbe953603a0f957bbc310bf5b403c364abe19ca
-  data.tar.gz: 7be1253854d4ebe732fefb896471e7d9f51df1b2adb5f27189f8d4ec186b3085
+  metadata.gz: '0119bb4269d493240babf4f372fa2f4ef88f514535521ea3c7c6e38b731fcaec'
+  data.tar.gz: 78febf371ce786efe61e6e0ff8ce4825b758c29b951ae8e8c047be79a2da0237
 SHA512:
-  metadata.gz: 19b8bcf6993c4c4d21ecfaa94ddc5349cb4c6cef29c11494d3cb1f48b4aab35faa08f99dda8801e1a5806d9149918ab836fef8579d39d1ccc5eb295c6c4a8251
-  data.tar.gz: df67b8477332e2742af34589189726dbb440edc3f6645b26e235ec37d6d594bb38aa86840cba0090d8e2e5c79b783c6a989a79bcb54f07eeae0e4f7a04e7de24
+  metadata.gz: 001ba186351e917c4e5b4e1a44759b0c190052b1552951ad1edbfa1df487b146b363fa1ed44e5aa502aaf04ed11883ca27851714772ca9357241f9b91ee40ac5
+  data.tar.gz: 9b1c95ea79e3dc111d2adac1a92532e9b8d51dbc72a2e39788213358082576ca717eb3c64c9d26b6da3acb58640ff242ff48e411059281acd3fab32dd071a2c6

data/CHANGELOG.md

@@ -6,6 +6,60 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [2.0.0] - 2026-04-24
+
+Vident 2.0 is a ground-up rearchitecture of the DSL, attribute resolution, and composition model. The public shape of `stimulus do ... end`, `root_element`, `child_element`, outlets, props, and the `stimulus_*:` prop/kwarg API is preserved for common cases, but several internals and a handful of edge-case behaviours changed. See `doc/reviews/v1-gotchas.md` for the full list of fixed gotchas; the highlights are below.
+
+### Breaking
+
+- **Namespace consolidation.** The `Vident2::*` namespace used during side-by-side development has been removed. Everything now lives under `Vident::*` directly: `Vident::Component`, `Vident::Capabilities::*`, `Vident::Phlex::HTML`, `Vident::ViewComponent::Base`, `Vident::Stimulus::*` (value classes), `Vident::Internals::*` (DSL/Resolver/Plan). Upgrade path is a `s/Vident2::/Vident::/g` on project code.
+- **Legacy collection classes removed.** `Vident::StimulusAction`, `StimulusTarget`, `StimulusController`, `StimulusValue`, `StimulusParam`, `StimulusOutlet`, `StimulusClass`, and each of their `*Collection` companions (plus `StimulusBuilder`, `StimulusDataAttributeBuilder`, `StimulusAttributeBase`, `StimulusAttributes`, `StimulusAction::Descriptor`) are gone. The 2.0 equivalents live under `Vident::Stimulus::*` (`Action`, `Target`, `Controller`, `Value`, `Param`, `Outlet`, `ClassMap`, `Collection`). `#to_h` now uses **Symbol keys** uniformly; V1 returned String keys for some primitives.
+- **`child_element` strictness.** Passing both `stimulus_<singular>:` and `stimulus_<plural>:` kwargs now raises `ArgumentError` (`"mutually exclusive — pass one or the other."`). V1 silently dropped the singular when the plural was an empty array (latent since 1.0.0, see "Fixed" below). Workaround at call sites that relied on the V1 shape: `stimulus_targets: [:input, *control_targets]`.
+- **`stimulus_controllers:` prop appends instead of replacing.** V1 replaced the implied controller when you passed `stimulus_controllers:` at render time; V2 appends, so the root element carries `data-controller="implied extra"`. Migration: if you wanted to *replace*, add `no_stimulus_controller` at the class level.
+- **Outlet DSL procs now resolve.** V1 silently passed a proc through as the outlet selector string, emitting literal `#<Proc:0x...>`. V2 evaluates the proc in the instance binding and emits the returned string. This turns previously broken code into working code, but if you relied on the proc-as-identity string for some reason, you'll now see a different data attribute.
+- **`nil` vs `false` drop rule.** V1 dropped both `nil` and `false` proc returns silently via a `blank?` filter. V2 drops only `nil`; `false` reaches the parser and raises `Vident::ParseError`. Fix: return `nil` (not `false`) to mean "don't emit this entry."
+- **`no_stimulus_controller` + DSL body now raises loudly.** V1 raised a bare `StandardError` at instance init. V2 raises `Vident::DeclarationError` at `stimulus do ... end` time with the offending class name and caller location in the message.
+- **StableId strategy.** Unchanged from 1.0, but reiterated here because it's the biggest gotcha during upgrade. `Vident::StableId` requires an explicit `strategy` and per-request seed — `bin/rails generate vident:install` sets both up correctly.
+
+### Added
+
+- **Fluent action DSL.** Inside `stimulus do ... end`, the singular `action(...)` call returns a chainable builder: `action(:escape).on(:keydown).keyboard("esc").window`, `action(:save).modifier(:prevent, :stop)`, `action(:delete).when { admin? }`. Chain methods: `.on`, `.call_method`, `.modifier`, `.keyboard`, `.window`, `.on_controller`, `.when`.
+- **Kwargs shorthand for actions.** `action :save, on: :click, modifier: [:prevent, :stop], keyboard: "ctrl+s", window: true, on_controller: :admin, call_method: :handle_save, when: -> { ... }` — equivalent to the fluent chain, pick whichever reads better. Unknown kwargs raise `ArgumentError`.
+- **Controller aliases.** `controller "admin/users", as: :admin` inside `stimulus do` declares a short alias; `action(...).on_controller(:admin)` or `action(..., on_controller: :admin)` then routes through it. Unknown alias refs raise `Vident::DeclarationError`. Runtime inputs (`stimulus_actions: [{method: :save, controller: :admin}]`) resolve the same map.
+- **Capability mixin composition.** `Vident::Component` is a composition root that includes twelve focused capability mixins (`Tailwind`, `Declarable`, `Identifiable`, `StimulusDeclaring`, `StimulusParsing`, `StimulusMutation`, `StimulusDraft`, `StimulusDataEmitting`, `ClassListBuilding`, `RootElementRendering`, `ChildElementRendering`, `Inspectable`), plus an opt-in `Caching` mixin (thirteen in total, including Caching). Mixin order mirrors capability dependencies.
+- **Singular DSL primitives.** `value(:name, *, **)`, `param(:name, *, **)`, `outlet(:name, *, **)`, `class_map(:name, *, **)`, `controller(path, as: nil)`, `controllers(*paths)`, `target(:name).when { ... }` — full set of singular entry points alongside the plural forms.
+- **Draft → Plan seal pattern.** Internal: `after_component_initialize` mutators (e.g. `add_stimulus_actions`) still work against a mutable Draft; the Draft seals into an immutable Plan once rendering begins. Prevents the V1 "mutator silently ignored post-render" class of bug.
+- **Phase-split proc resolution.** DSL procs are evaluated in two phases: static (after_initialize, no `view_context`) and procs (`before_template` / `before_render`, `view_context`/`helpers` wired). Procs can now call Rails helpers (`number_with_precision`, url helpers, `t`, `l`, etc.) safely — already backported to 1.0.2.
+- `has_stimulus_controller` class method re-enables the implied controller in a subclass after a parent declared `no_stimulus_controller` (#27).
+- `root_element_class_list(extra = nil)` and `root_element_data_attributes` for components rendering through third-party tag helpers instead of `root_element(...)` (#25; V1 names `render_classes` / `stimulus_data_attributes` — see UPGRADING.md §8).
+- Class-level Stimulus builders — `MyComponent.stimulus_target(:x)` etc. — return value objects without a component instance (#18).
+- `Vident::Types::*` — seven named Literal unions for the built-in `stimulus_*:` prop types, reusable from user components (#16).
+- `cache_component(*keys, **options, &block)` on both adapter base classes — fragment-caches the block using the Vident-computed `cache_key` (#13).
+- Shared `Vident::Stimulus::Base` + `Combinable` for the value classes: `with(**overrides)` combinator, canonical `deconstruct_keys` (restores pattern matching — previously shadowed by the `to_h` data-attribute override), and `Action.parse([event, existing_action])` merge form (#28).
+
+### Fixed
+
+- `child_element` no longer silently drops a `stimulus_<singular>:` kwarg when `stimulus_<plural>:` is also passed with an empty array. The V1 helper returned early on an empty-but-truthy plural, losing the singular and emitting no data attribute — latent since 1.0.0, surfaced by call sites like `child_element(:input, stimulus_target: :input, stimulus_targets: control_targets)` where `control_targets` defaulted to `[]`. V2 raises `ArgumentError` on both-set (see Breaking); workaround on 1.x is `stimulus_targets: [:input, *control_targets]` (also works on 2.x).
+- Outlet DSL procs now resolve instead of being treated as identity strings (see Breaking).
+- `add_stimulus_actions([:click, :handle])` now treats the Array as *one* action descriptor (event + method pair) rather than splatting it into two separate `:click` and `:handle` actions. Matches the DSL's `actions [:click, :handle]` semantics — the V1 asymmetry is gone.
+
+### Removed
+
+- `Vident::StimulusAction::Descriptor` typed data class. The V2 equivalent is `Vident::Stimulus::Action` itself — the Hash shape accepted by the DSL (`{event:, method:, controller:, options:, keyboard:, window:}`) parses directly into the value class now. Callers that instantiated `Descriptor` explicitly should swap to `Vident::Stimulus::Action.parse(hash, implied: ...)` or just pass the Hash.
+- Legacy top-level requires like `require "vident/stimulus_action"`. The main `require "vident"` loads the whole surface; deep requires for individual value classes still work (`require "vident/stimulus/action"`) but are no longer the documented path.
+
+
+## [1.0.2] - 2026-04-21
+
+### Changed
+
+- Stimulus DSL procs (`values foo: -> { ... }`, `actions -> { ... }`, etc.) now resolve at **render time** — Phlex's `before_template` for `Vident::Phlex::HTML`, ViewComponent's `before_render` for `Vident::ViewComponent::Base` — instead of in `after_initialize`. Procs can now reach `helpers` / `view_context`, so they can call Rails helpers (`number_with_precision`, `t`, `l`, url helpers, etc.). Non-proc DSL entries still land in the collections at init time, so `after_component_initialize` mutators and external readers see them in the same order as before.
+
+### Added
+
+- `phlex_helpers :name1, :name2, ...` class macro on `Vident::Phlex::HTML` — opts the component into Phlex's per-helper Rails adapters (`Phlex::Rails::Helpers::<CamelCase>`) so DSL procs can call helpers bare (`number_with_precision(@amount, precision: 2)`) instead of via the deprecated `helpers.<method>`. Unknown helper names raise `ArgumentError` at class definition.
+
+
 ## [1.0.0] - 2026-04-19
 
 ### Breaking

data/README.md

@@ -79,9 +79,13 @@ class ButtonComponent < Vident::ViewComponent::Base
   
   # Configure Stimulus integration
   stimulus do
-    # Setup actions, including with proc to evaluate on instance 
-    actions [:click, :handle_click], 
-            -> { [stimulus_scoped_event(:my_custom_event), :handle_this] if should_handle_this? }
+    # Fluent action DSL: reads left-to-right as "the handle_click method fires on the click event".
+    action(:handle_click).on(:click)
+    # Kwargs shorthand — same result, pick whichever reads better:
+    action :handle_submit, on: :submit, modifier: [:prevent, :stop]
+    # Proc for conditional / cross-component wiring, evaluated in the instance at render time.
+    action(-> { [stimulus_scoped_event(:my_custom_event), :handle_this] if should_handle_this? })
+
     # Map the clicked_count prop as a Stimulus value
     values_from_props :clicked_count
     # Dynamic values using procs (evaluated in component context)
@@ -178,7 +182,7 @@ Use the component in your views:
 <%= render ButtonComponent.new(text: "Cancel", url: "/home", style: :secondary) %>
 
 <!-- Override things -->
-<%= render ButtonComponent.new(text: "Cancel", url: "/home" classes: "bg-red-900", html_options: {role: "button"}) %>
+<%= render ButtonComponent.new(text: "Cancel", url: "/home", classes: "bg-red-900", html_options: {role: "button"}) %>
 ```
 
 The rendered HTML includes all Stimulus data attributes:
@@ -227,7 +231,7 @@ class CardComponent < Vident::ViewComponent::Base
   # Property with validation
   prop :size, _Union(:small, :medium, :large), default: :medium
   
-  # Boolean property (creates predicate method)
+  # Boolean property (pass `predicate: :public` to also generate a `?` method)
   prop :featured, _Boolean, default: false
 end
 ```
@@ -271,7 +275,7 @@ The `root_element` helper method renders your component's root element with all
 ```ruby
 # In your component class
 def root_element_classes
-  ["card", featured? ? "card-featured" : nil]
+  ["card", @featured ? "card-featured" : nil]
 end
 
 private
@@ -362,17 +366,41 @@ class ToggleComponent < Vident::ViewComponent::Base
 end
 ```
 
-**Action modifiers** — the Array form `[:click, :method]` handles the common case. For Stimulus's modifier syntax (`:once`/`:prevent`/`:stop`/`:passive`/`:"!passive"`/`:capture`/`:self`, keyboard filters, `@window`), pass a Hash or a `Vident::StimulusAction::Descriptor`:
+**Action modifiers — fluent DSL.** Singular `action(...)` returns a builder you chain with event, modifier, keyboard, and window setters. Kwargs shorthand is equivalent:
 
 ```ruby
-actions({event: :click,   method: :submit, options: [:once, :prevent]})
-actions({event: :keydown, method: :on_key, keyboard: "ctrl+a"})
-actions({event: :resize,  method: :on_resize, window: true})
-# or, if you want a typed, passable object:
-actions Vident::StimulusAction::Descriptor.new(event: :click, method: :save, options: [:prevent])
+stimulus do
+  action(:submit).on(:click).modifier(:once, :prevent)          # click:once:prevent->implied#submit
+  action(:on_key).on(:keydown).keyboard("ctrl+a")               # keydown.ctrl+a->implied#onKey
+  action(:on_resize).on(:resize).window                         # resize@window->implied#onResize
+
+  # kwargs shorthand — same result:
+  action :submit,     on: :click,   modifier: [:once, :prevent]
+  action :on_key,     on: :keydown, keyboard: "ctrl+a"
+  action :on_resize,  on: :resize,  window: true
+  action :save,       on: :click,   call_method: :handle_save
+
+  # conditional inclusion via `.when` / `when:`:
+  action(:delete).when { admin? }
+end
 ```
 
-Unknown option symbols raise `ArgumentError` at attribute construction, not at render.
+Chain methods: `.on`, `.call_method`, `.modifier`, `.keyboard`, `.window`, `.on_controller`, `.when`. Recognised kwargs: `on:`, `call_method:`, `modifier:` (Symbol or Array), `keyboard:`, `window:`, `on_controller:`, `when:`. Unknown kwargs or modifier symbols raise `ArgumentError`.
+
+**Controller aliases.** Declare a short alias with `controller "path", as: :sym`, then reference it from action entries via the fluent `.on_controller(:sym)` or the `on_controller: :sym` kwarg:
+
+```ruby
+stimulus do
+  controller "admin/users", as: :admin
+
+  action(:save).on(:click).on_controller(:admin)     # click->admin--users#save
+  action :save, on: :click, on_controller: :admin    # same, kwargs form
+end
+```
+
+Unknown aliases raise `Vident::DeclarationError` at render time.
+
+**Legacy Hash form.** Still accepted for compat — `actions({event: :click, method: :submit, options: [:once, :prevent]})` parses the same way. The Hash descriptor is folded directly into `Vident::Stimulus::Action` — pass a Hash and it is parsed in place. Accepted keys: `method:`, `event:`, `controller:`, `options:`, `keyboard:`, `window:`.
 
 ### Dynamic Values and Classes with Procs
 
@@ -415,7 +443,10 @@ class DynamicComponent < Vident::ViewComponent::Base
 end
 ```
 
-Procs have access to instance variables, component methods, and Rails helpers.
+Procs have access to instance variables and component methods. They run at render time (Phlex `before_template` / ViewComponent `before_render`), so they can reach the view context:
+
+- **Phlex**: `helpers` is deprecated in phlex-rails. Opt in per Rails helper by including the matching adapter — e.g. `include Phlex::Rails::Helpers::NumberWithPrecision` — and call the helper bare (`number_with_precision(@amount, precision: 2)`) inside the proc. Vident ships a `phlex_helpers :number_with_precision, :t, :l` class macro on `Vident::Phlex::HTML` that does the right include for each name. See [phlex.fun/rails/helpers](https://www.phlex.fun/rails/helpers) for the full list of adapters.
+- **ViewComponent**: call `helpers.<method>` or `view_context.<method>` directly.
 
 **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:
 
@@ -486,14 +517,14 @@ class MyComponent < Vident::ViewComponent::Base
     # This would generate: "my-component:dataLoaded"
     puts stimulus_scoped_event(:data_loaded)
     
-    # For window events, this generates: "my-component:dataLoaded@window" 
+    # For window events, this generates: :"my-component:dataLoaded@window" 
     puts stimulus_scoped_event_on_window(:data_loaded)
   end
 end
 
 # 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"
+MyComponent.stimulus_scoped_event(:data_loaded)      # => :"my-component:dataLoaded"
+MyComponent.new.stimulus_scoped_event(:data_loaded)  # => :"my-component:dataLoaded"
 ```
 
 This is useful for:
@@ -529,7 +560,7 @@ class CustomComponent < Vident::ViewComponent::Base
 end
 ```
 
-All stimulus props accept Symbol paths as well as Strings (e.g. `stimulus_controllers: [:custom, :"admin/users"]`). `stimulus_values:` and `stimulus_classes:` additionally accept Array entries (for cross-controller: `[["admin/users", :name, "value"]]`) and pre-built `StimulusValue`/`StimulusValueCollection` / `StimulusClass`/`StimulusClassCollection` instances, so you can compose attribute sets outside the component and pass them in.
+All stimulus props accept Symbol paths as well as Strings (e.g. `stimulus_controllers: [:custom, :"admin/users"]`). `stimulus_values:` and `stimulus_classes:` additionally accept Array entries (for cross-controller: `[["admin/users", :name, "value"]]`) and pre-built `Vident::Stimulus::Value` / `Vident::Stimulus::ClassMap` instances, so you can compose attribute sets outside the component and pass them in.
 
 or you can use tag helpers to generate HTML with Stimulus attributes:
 

data/lib/vident/view_component/base.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+require "set"
+
 module Vident
   module ViewComponent
     class Base < ::ViewComponent::Base
-      include Vident::Component
+      include ::Vident::Component
 
       class << self
         def cache_component_modified_time
@@ -17,7 +21,6 @@ module Vident
         end
 
         def template_path
-          # Check for common ViewComponent template extensions in order of preference
           extensions = [".html.erb", ".erb", ".html.haml", ".haml", ".html.slim", ".slim"]
           base_path = Rails.root.join(components_base_path, virtual_path)
 
@@ -26,7 +29,6 @@ module Vident
             return potential_path if File.exist?(potential_path)
           end
 
-          # Return the default .html.erb path if no template is found
           Rails.root.join(components_base_path, "#{virtual_path}.html.erb").to_s
         end
 
@@ -39,12 +41,30 @@ module Vident
         end
       end
 
-      SELF_CLOSING_TAGS = Set[:area, :base, :br, :col, :embed, :hr, :img, :input, :link, :meta, :param, :source, :track, :wbr].freeze
+      SELF_CLOSING_TAGS = Set[*%i[area base br col embed hr img input link meta param source track wbr]].freeze
+
+      # DSL procs stay unresolved until `@view_context` is set; resolve them here.
+      def before_render
+        resolve_stimulus_attributes_at_render_time
+        super
+      end
 
+      # Fragment-cache the block's rendered String using the Vident-computed
+      # `cache_key`. Useful inside a `call` method; for sidecar ERB templates
+      # use the native `<% cache cache_key do %>` pattern instead.
+      def cache_component(*extra_keys, expires_in: nil, &block)
+        unless respond_to?(:cacheable?) && cacheable?
+          raise ::Vident::ConfigurationError,
+            "#{self.class.name} is not cacheable — `include Vident::Caching` and declare `with_cache_key` first."
+        end
+        ::Rails.cache.fetch([cache_key, *extra_keys], expires_in: expires_in) { capture(&block) }
+      end
+
+      # Capture block first so children can mutate this Draft before it seals (outlet-host pattern).
       def root_element(**overrides, &block)
         tag_type = root_element_tag_type
-        child_content = view_context.capture(self, &block) if block_given? # Evaluate before generating the outer tag options to ensure DSL methods are executed
-        options = resolve_root_element_attributes_before_render(overrides)
+        child_content = view_context.capture(self, &block) if block
+        options = build_root_element_attributes(overrides)
         if SELF_CLOSING_TAGS.include?(tag_type)
           view_context.tag(tag_type, options)
         else
@@ -52,61 +72,41 @@ module Vident
         end
       end
 
-      def as_stimulus_targets(...)
-        to_data_attribute_string(**stimulus_targets(...))
-      end
+      def as_stimulus_targets(...) = to_data_attribute_string(**stimulus_targets(...).to_h)
 
-      def as_stimulus_target(...)
-        to_data_attribute_string(**stimulus_target(...))
-      end
+      def as_stimulus_target(...) = to_data_attribute_string(**stimulus_target(...).to_h)
 
-      def as_stimulus_actions(...)
-        to_data_attribute_string(**stimulus_actions(...))
-      end
+      def as_stimulus_actions(...) = to_data_attribute_string(**stimulus_actions(...).to_h)
 
-      def as_stimulus_action(...)
-        to_data_attribute_string(**stimulus_action(...))
-      end
+      def as_stimulus_action(...) = to_data_attribute_string(**stimulus_action(...).to_h)
 
-      def as_stimulus_controllers(...)
-        to_data_attribute_string(**stimulus_controllers(...))
-      end
+      def as_stimulus_controllers(...) = to_data_attribute_string(**stimulus_controllers(...).to_h)
 
-      def as_stimulus_controller(...)
-        to_data_attribute_string(**stimulus_controller(...))
-      end
+      def as_stimulus_controller(...) = to_data_attribute_string(**stimulus_controller(...).to_h)
 
-      def as_stimulus_outlets(...)
-        to_data_attribute_string(**stimulus_outlets(...))
-      end
+      def as_stimulus_outlets(...) = to_data_attribute_string(**stimulus_outlets(...).to_h)
 
-      def as_stimulus_outlet(...)
-        to_data_attribute_string(**stimulus_outlet(...))
-      end
+      def as_stimulus_outlet(...) = to_data_attribute_string(**stimulus_outlet(...).to_h)
 
-      def as_stimulus_values(...)
-        to_data_attribute_string(**stimulus_values(...))
-      end
+      def as_stimulus_values(...) = to_data_attribute_string(**stimulus_values(...).to_h)
 
-      def as_stimulus_value(...)
-        to_data_attribute_string(**stimulus_value(...))
-      end
+      def as_stimulus_value(...) = to_data_attribute_string(**stimulus_value(...).to_h)
 
-      def as_stimulus_params(...)
-        to_data_attribute_string(**stimulus_params(...))
-      end
+      def as_stimulus_params(...) = to_data_attribute_string(**stimulus_params(...).to_h)
 
-      def as_stimulus_param(...)
-        to_data_attribute_string(**stimulus_param(...))
-      end
+      def as_stimulus_param(...) = to_data_attribute_string(**stimulus_param(...).to_h)
 
-      def as_stimulus_classes(...)
-        to_data_attribute_string(**stimulus_classes(...))
-      end
+      def as_stimulus_classes(...) = to_data_attribute_string(**stimulus_classes(...).to_h)
 
-      def as_stimulus_class(...)
-        to_data_attribute_string(**stimulus_class(...))
-      end
+      def as_stimulus_class(...) = to_data_attribute_string(**stimulus_class(...).to_h)
+
+      alias_method :as_target, :as_stimulus_target
+      alias_method :as_action, :as_stimulus_action
+      alias_method :as_controller, :as_stimulus_controller
+      alias_method :as_outlet, :as_stimulus_outlet
+      alias_method :as_value, :as_stimulus_value
+      alias_method :as_param, :as_stimulus_param
+      alias_method :as_class, :as_stimulus_class
 
       private
 

data/lib/vident/view_component.rb

@@ -1,6 +1,7 @@
-require "vident/view_component/version"
+# frozen_string_literal: true
+
+require "view_component"
 require "vident/view_component/base"
-require "vident/view_component/engine" if defined?(Rails)
 
 module Vident
   module ViewComponent

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vident-view_component
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
@@ -55,14 +55,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: view_component
   requirement: !ruby/object:Gem::Requirement
@@ -95,8 +95,6 @@ files:
 - README.md
 - lib/vident/view_component.rb
 - lib/vident/view_component/base.rb
-- lib/vident/view_component/engine.rb
-- lib/vident/view_component/version.rb
 homepage: https://github.com/stevegeek/vident
 licenses:
 - MIT

data/lib/vident/view_component/engine.rb

@@ -1,17 +0,0 @@
-module Vident
-  module ViewComponent
-    class Engine < ::Rails::Engine
-      lib_path = File.expand_path("../../../../lib/", __FILE__)
-      config.autoload_paths << lib_path
-      config.eager_load_paths << lib_path
-
-      config.before_initialize do
-        Rails.autoloaders.each do |autoloader|
-          autoloader.inflector.inflect(
-            "version" => "VERSION"
-          )
-        end
-      end
-    end
-  end
-end

data/lib/vident/view_component/version.rb

@@ -1,5 +0,0 @@
-module Vident
-  module ViewComponent
-    VERSION = Vident::VERSION
-  end
-end