view_component_reducible 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b815772f1cd9c519f38613dc6629c94fb0951a2095d4434a092fdbae142b7564
+  data.tar.gz: 65a95eba94127d4373b35512feaa8587a622ed91a47ad425eec732922e4a5e4e
+SHA512:
+  metadata.gz: 4ed5dbd74b6a77153e4226f4c141834879c0ae668d711eeec1b8486e10a9de283f413011ff3469977e410bb44d8b5e4758b2ff728a5d0cb56a41b422a29f5601
+  data.tar.gz: 66817291cf7433b3575772a9aa6fbf00b5449e8ddd470fb8fa95a00373e007a26d54d7b40c91bf159212f29bb9bcd7602fd8160d86b5a1537eff589e5b78ed9b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 manabeai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,15 @@
+# view_component_reducible
+
+![sample](doc/img/sample.png)
+
+This sample shows state transitions and partial updates powered entirely by ViewComponent.
+The only thing you add in Rails is a single endpoint:
+
+```rb
+mount ViewComponentReducible::Engine, at: "/vcr"
+```
+
+Everything else stays inside ViewComponent—no extra endpoints, controllers, WebSockets, or JS frameworks required.
+
+view_component_reducible brings reducer-based state transitions
+to Rails ViewComponent, inspired by TEA (The Elm Architecture).

data/lib/view_component_reducible/adapter/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module Adapter
+    # Base adapter interface for envelope serialization.
+    class Base
+      # @param secret [String]
+      def initialize(secret:)
+        @secret = secret
+      end
+
+      # Encode envelope to a client-safe token.
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request:)
+        raise NotImplementedError
+      end
+
+      # Load envelope from a request.
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/view_component_reducible/adapter/hidden_field.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/message_verifier"
+
+module ViewComponentReducible
+  module Adapter
+    # Hidden field adapter using signed payloads.
+    class HiddenField < Base
+      # @return [ActiveSupport::MessageVerifier]
+      def verifier
+        @verifier ||= ActiveSupport::MessageVerifier.new(@secret, digest: "SHA256", serializer: JSON)
+      end
+
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request:)
+        verifier.generate(envelope)
+      end
+
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        signed = request.params.fetch("vcr_state")
+        verifier.verify(signed)
+      end
+    end
+  end
+end

data/lib/view_component_reducible/adapter/session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/message_verifier"
+require "securerandom"
+
+module ViewComponentReducible
+  module Adapter
+    # Session adapter storing envelope in server session.
+    class Session < Base
+      # @return [ActiveSupport::MessageVerifier]
+      def verifier
+        @verifier ||= ActiveSupport::MessageVerifier.new(@secret, digest: "SHA256", serializer: JSON)
+      end
+
+      # @param envelope [Hash]
+      # @param request [ActionDispatch::Request]
+      # @return [String]
+      def dump(envelope, request:)
+        key = SecureRandom.hex(16)
+        request.session["vcr:#{key}"] = envelope
+        verifier.generate({ "k" => key })
+      end
+
+      # @param request [ActionDispatch::Request]
+      # @return [Hash]
+      def load(request:)
+        signed = request.params.fetch("vcr_state")
+        payload = verifier.verify(signed)
+        key = payload.fetch("k")
+        request.session.fetch("vcr:#{key}")
+      end
+    end
+  end
+end

data/lib/view_component_reducible/component.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  # Include to enable the component state DSL and helpers.
+  module Component
+    # Hook to include DSL and class methods.
+    # @param base [Class]
+    # @return [void]
+    def self.included(base)
+      base.include(State::DSL)
+      base.extend(ClassMethods)
+    end
+
+    # @return [Hash, nil]
+    attr_reader :vcr_envelope
+    # @return [String, nil]
+    attr_reader :vcr_state_token
+
+    # @param vcr_envelope [Hash, nil]
+    # @param vcr_state_token [String, nil]
+    def initialize(vcr_envelope: nil, vcr_state_token: nil, **kwargs)
+      @vcr_envelope = vcr_envelope
+      @vcr_state_token = vcr_state_token
+      return unless defined?(super)
+
+      kwargs.empty? ? super() : super(**kwargs)
+    end
+
+    # Build state hash for rendering from the envelope.
+    # @return [Hash{String=>Hash}]
+    def vcr_state
+      return { "data" => {}, "meta" => {} } if vcr_envelope.nil?
+
+      schema = self.class.vcr_state_schema
+      data, meta = schema.build(vcr_envelope["data"], vcr_envelope["meta"])
+      { "data" => data, "meta" => meta }
+    end
+
+    # Optional DOM target id for updates.
+    # @param path [String]
+    # @return [String]
+    def vcr_dom_id(path:)
+      "vcr:#{self.class.vcr_id}:#{path}"
+    end
+
+    module ClassMethods
+      # Stable component identifier for envelopes.
+      # @return [String]
+      def vcr_id
+        name.to_s
+      end
+    end
+  end
+end

data/lib/view_component_reducible/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  # Global configuration for adapter and secrets.
+  class Configuration
+    # @return [Class]
+    attr_accessor :adapter, :secret
+
+    def initialize
+      @adapter = Adapter::Session
+      @secret = nil
+    end
+
+    # Build adapter instance for a controller request.
+    # @param controller [ActionController::Base]
+    # @param adapter_class [Class, nil]
+    # @return [ViewComponentReducible::Adapter::Base]
+    def adapter_for(controller, adapter_class: nil)
+      resolved_secret = secret || default_secret
+      raise "ViewComponentReducible secret is missing" if resolved_secret.nil?
+
+      (adapter_class || adapter).new(secret: resolved_secret)
+    end
+
+    private
+
+    def default_secret
+      return Rails.application.secret_key_base if defined?(Rails) && Rails.respond_to?(:application)
+
+      nil
+    end
+  end
+end

data/lib/view_component_reducible/dispatch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ViewComponentReducible
+  # Helpers for dispatch responses.
+  module Dispatch
+    # Inject a signed state token into HTML.
+    # @param html [String]
+    # @param signed_state [String]
+    # @return [String]
+    def self.inject_state(html, signed_state)
+      meta = %(<meta name="vcr-state" content="#{ERB::Util.html_escape(signed_state)}">)
+      script = <<~SCRIPT.chomp
+        <script>
+        (function() {
+          var meta = document.querySelector('meta[name="vcr-state"]');
+          if (!meta) return;
+          var state = meta.getAttribute('content');
+          var inputs = document.querySelectorAll('input[name="vcr_state"]');
+          inputs.forEach(function(input) { input.value = state; });
+        })();
+        </script>
+      SCRIPT
+
+      injection = meta + script
+      html.include?("</head>") ? html.sub("</head>", "#{injection}</head>") : (injection + html)
+    end
+  end
+end

data/lib/view_component_reducible/dispatch_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "action_controller"
+
+module ViewComponentReducible
+  # Rails controller entry for dispatch requests.
+  class DispatchController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    # @param adapter_class [Class]
+    # @return [Class, nil]
+    def self.vcr_adapter(adapter_class = nil)
+      return @vcr_adapter if adapter_class.nil?
+
+      @vcr_adapter = adapter_class
+    end
+
+    # @return [void]
+    def call
+      adapter_class = self.class.vcr_adapter || ViewComponentReducible.config.adapter
+      adapter = ViewComponentReducible.config.adapter_for(self, adapter_class: adapter_class)
+      envelope = adapter.load(request:)
+      msg = ViewComponentReducible::Msg.from_params(params)
+      target_path = params.fetch("vcr_target_path", envelope["path"])
+
+      runtime = ViewComponentReducible::Runtime.new
+      new_envelope, html = runtime.call(
+        envelope:,
+        msg:,
+        target_path:,
+        controller: self
+      )
+
+      signed = adapter.dump(new_envelope, request:)
+      if params["vcr_partial"] == "1"
+        partial_html = runtime.render_target(envelope: new_envelope, target_path:, controller: self)
+        response.set_header("X-VCR-State", signed)
+        render html: partial_html, content_type: "text/html"
+      else
+        render html: ViewComponentReducible::Dispatch.inject_state(html, signed), content_type: "text/html"
+      end
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      render status: 400, plain: "Invalid state signature"
+    end
+  end
+end

data/lib/view_component_reducible/engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module ViewComponentReducible
+  # Rails engine for mounting dispatch routes.
+  class Engine < ::Rails::Engine
+    isolate_namespace ViewComponentReducible
+
+    routes.draw do
+      post "/dispatch", to: "dispatch#call"
+    end
+  end
+end

data/lib/view_component_reducible/helpers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ViewComponentReducible
+  # View helpers for dispatching messages to the VCR endpoint.
+  module Helpers
+    # Wrap component markup with a boundary for partial updates.
+    # @param path [String]
+    # @yield block for component content
+    # @return [String]
+    def vcr_boundary(path:, &block)
+      content_tag(:div, capture(&block), data: { vcr_path: path })
+    end
+
+    # Build a dispatch form with hidden fields for the VCR endpoint.
+    # @param state [String] signed state token
+    # @param msg_type [String]
+    # @param msg_payload [Hash, String]
+    # @param target_path [String]
+    # @param url [String]
+    # @yield block for the form body (e.g., submit button)
+    # @return [String]
+    def vcr_dispatch_form(state:, msg_type:, msg_payload: {}, target_path: "root", url: "/vcr/dispatch", &block)
+      payload = msg_payload.is_a?(String) ? msg_payload : JSON.generate(msg_payload)
+
+      form_tag(url, method: :post, data: { vcr_form: true }) do
+        body = [
+          hidden_field_tag("vcr_state", state),
+          hidden_field_tag("vcr_msg_type", msg_type),
+          hidden_field_tag("vcr_msg_payload", payload),
+          hidden_field_tag("vcr_target_path", target_path),
+          (block_given? ? capture(&block) : "")
+        ]
+        safe_join(body)
+      end
+    end
+
+    # Insert the minimal JS dispatcher for partial updates.
+    # @return [String]
+    def vcr_dispatch_script_tag
+      js = <<~JS
+        (function() {
+          if (window.__vcrDispatchInstalled) return;
+          window.__vcrDispatchInstalled = true;
+          document.addEventListener("submit", function(event) {
+            var form = event.target;
+            if (!(form instanceof HTMLFormElement)) return;
+            if (!form.matches("[data-vcr-form]")) return;
+            event.preventDefault();
+            var formData = new FormData(form);
+            formData.append("vcr_partial", "1");
+            fetch(form.action, {
+              method: (form.method || "POST").toUpperCase(),
+              body: formData,
+              headers: { "X-Requested-With": "XMLHttpRequest" }
+            })
+              .then(function(response) {
+                var state = response.headers.get("X-VCR-State");
+                return response.text().then(function(html) {
+                  return { html: html, state: state };
+                });
+              })
+              .then(function(payload) {
+                var targetPath = formData.get("vcr_target_path");
+                var parser = new DOMParser();
+                var doc = parser.parseFromString(payload.html, "text/html");
+                var newNode = doc.querySelector('[data-vcr-path="' + targetPath + '"]') || doc.body.firstElementChild;
+                var current = document.querySelector('[data-vcr-path="' + targetPath + '"]');
+                if (newNode && current) {
+                  current.replaceWith(newNode);
+                }
+                if (payload.state) {
+                  document.querySelectorAll('input[name="vcr_state"]').forEach(function(input) {
+                    input.value = payload.state;
+                  });
+                }
+              });
+          });
+        })();
+      JS
+      content_tag(:script, js.html_safe)
+    end
+  end
+end

data/lib/view_component_reducible/msg.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ViewComponentReducible
+  # Message payload sent from the client.
+  Msg = Struct.new(:type, :payload, keyword_init: true) do
+    # Build a Msg from request params.
+    # @param params [Hash]
+    # @return [ViewComponentReducible::Msg]
+    def self.from_params(params)
+      type = params.fetch("vcr_msg_type")
+      payload_json = params["vcr_msg_payload"]
+      payload = payload_json && payload_json != "" ? JSON.parse(payload_json) : {}
+      new(type:, payload:)
+    end
+  end
+end

data/lib/view_component_reducible/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ViewComponentReducible
+  # Railtie for wiring helpers into ActionView.
+  class Railtie < ::Rails::Railtie
+    initializer "view_component_reducible.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ViewComponentReducible::Helpers
+      end
+    end
+  end
+end

data/lib/view_component_reducible/runtime.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  # Core runtime for dispatching messages and rendering components.
+  class Runtime
+    MAX_EFFECT_STEPS = 8
+
+    # @param envelope [Hash]
+    # @param msg [ViewComponentReducible::Msg]
+    # @param target_path [String]
+    # @param controller [ActionController::Base]
+    # @return [Array<Hash, String>] [new_envelope, html]
+    def call(envelope:, msg:, target_path:, controller:)
+      root_klass = ViewComponentReducible.registry.fetch(envelope["root"])
+      new_env = deep_dup(envelope)
+
+      new_env = dispatch_to_path(root_klass, new_env, msg, target_path, controller)
+      html = render_root(root_klass, new_env, controller)
+      [new_env, html]
+    end
+
+    # Render HTML for a specific path after state updates.
+    # @param envelope [Hash]
+    # @param target_path [String]
+    # @param controller [ActionController::Base]
+    # @return [String]
+    def render_target(envelope:, target_path:, controller:)
+      root_klass = ViewComponentReducible.registry.fetch(envelope["root"])
+      component_klass, env = find_env_and_class(root_klass, envelope, target_path)
+      controller.view_context.render(component_klass.new(vcr_envelope: env))
+    end
+
+    private
+
+    def dispatch_to_path(root_klass, env, msg, target_path, controller)
+      if target_path == env["path"]
+        apply_reducer(root_klass, env, msg, controller)
+      else
+        child = env["children"].fetch(target_path) { raise KeyError, "Unknown path: #{target_path}" }
+        child_klass = ViewComponentReducible.registry.fetch(child["root"])
+        env["children"][target_path] = dispatch_to_path(child_klass, child, msg, target_path, controller)
+        env
+      end
+    end
+
+    def apply_reducer(component_klass, env, msg, controller)
+      component = component_klass.new(vcr_envelope: env)
+      schema = component_klass.vcr_state_schema
+      data, meta = schema.build(env["data"], env["meta"])
+      state = { "data" => data, "meta" => meta }
+
+      new_state, effects = component.reduce(state, msg)
+      env["data"] = new_state["data"]
+      env["meta"] = new_state["meta"]
+
+      run_effects(component_klass, env, effects, controller)
+    end
+
+    def run_effects(component_klass, env, effects, controller)
+      return env if effects.nil? || effects.empty?
+
+      effects_queue = effects.dup
+      steps = 0
+
+      while (eff = effects_queue.shift)
+        steps += 1
+        raise "Too many effect steps" if steps > MAX_EFFECT_STEPS
+
+        follow_msg = eff.call(controller: controller, envelope: env)
+        next unless follow_msg
+
+        component = component_klass.new(vcr_envelope: env)
+        schema = component_klass.vcr_state_schema
+        data, meta = schema.build(env["data"], env["meta"])
+        state = { "data" => data, "meta" => meta }
+
+        new_state, new_effects = component.reduce(state, follow_msg)
+        env["data"] = new_state["data"]
+        env["meta"] = new_state["meta"]
+        effects_queue.concat(Array(new_effects))
+      end
+
+      env
+    end
+
+    def render_root(root_klass, env, controller)
+      controller.view_context.render(root_klass.new(vcr_envelope: env))
+    end
+
+    def find_env_and_class(component_klass, env, target_path)
+      return [component_klass, env] if target_path == env["path"]
+
+      child = env["children"].fetch(target_path) { raise KeyError, "Unknown path: #{target_path}" }
+      child_klass = ViewComponentReducible.registry.fetch(child["root"])
+      find_env_and_class(child_klass, child, target_path)
+    end
+
+    def deep_dup(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+  end
+end

data/lib/view_component_reducible/state/dsl.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # DSL for defining state schemas on components.
+    module DSL
+      # Hook to extend class methods when included.
+      # @param base [Class]
+      # @return [void]
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Define a state schema for the component.
+        # @yield DSL block to declare fields.
+        # @return [void]
+        def state(&block)
+          schema = Schema.new
+          dsl = Builder.new(schema)
+          dsl.instance_eval(&block)
+          @vcr_state_schema = schema
+
+          define_singleton_method(:vcr_state_schema) { @vcr_state_schema }
+        end
+      end
+
+      class Builder
+        def initialize(schema) = (@schema = schema)
+
+        # Define a data field.
+        # @param name [Symbol]
+        # @param default [Object, #call]
+        # @return [void]
+        def field(name, default:)
+          @schema.add_field(name, default:, kind: :data)
+        end
+
+        # Define a meta field.
+        # @param name [Symbol]
+        # @param default [Object, #call]
+        # @return [void]
+        def meta(name, default:)
+          @schema.add_field(name, default:, kind: :meta)
+        end
+      end
+    end
+  end
+end

data/lib/view_component_reducible/state/envelope.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # Envelope builder for initial state payloads.
+    class Envelope
+      # Build an initial envelope for a component.
+      # @param root_component_klass [Class]
+      # @param path [String]
+      # @return [Hash{String=>Object}]
+      def self.initial(root_component_klass, path: "root")
+        schema = root_component_klass.vcr_state_schema
+        data, meta = schema.defaults
+        {
+          "v" => 1,
+          "root" => root_component_klass.vcr_id,
+          "path" => path,
+          "data" => data,
+          "children" => {},
+          "meta" => meta
+        }
+      end
+    end
+  end
+end

data/lib/view_component_reducible/state/schema.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  module State
+    # State schema for defining default fields and building state payloads.
+    class Schema
+      Field = Struct.new(:name, :default, :kind, keyword_init: true) # kind: :data or :meta
+
+      def initialize
+        @fields = []
+      end
+
+      # Add a field definition.
+      # @param name [Symbol]
+      # @param default [Object, #call]
+      # @param kind [Symbol] :data or :meta
+      # @return [void]
+      def add_field(name, default:, kind:)
+        @fields << Field.new(name:, default:, kind:)
+      end
+
+      # Build state hashes from input payloads.
+      # @param data_hash [Hash]
+      # @param meta_hash [Hash]
+      # @return [Array<Hash{String=>Object}>] [data, meta]
+      def build(data_hash, meta_hash)
+        data = {}
+        meta = {}
+        @fields.each do |field|
+          src = (field.kind == :meta ? meta_hash : data_hash) || {}
+          value = if src.key?(field.name.to_s)
+                    src[field.name.to_s]
+                  elsif src.key?(field.name)
+                    src[field.name]
+                  end
+          value = field.default.call if value.nil? && field.default.respond_to?(:call)
+          value = field.default if value.nil? && !field.default.respond_to?(:call)
+
+          if field.kind == :meta
+            meta[field.name.to_s] = value
+          else
+            data[field.name.to_s] = value
+          end
+        end
+        [data, meta]
+      end
+
+      # Build default state hashes.
+      # @return [Array<Hash{String=>Object}>] [data, meta]
+      def defaults
+        build({}, {})
+      end
+    end
+  end
+end

data/lib/view_component_reducible/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ViewComponentReducible
+  VERSION = "0.0.1"
+end

data/lib/view_component_reducible.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "view_component_reducible/version"
+require_relative "view_component_reducible/configuration"
+require_relative "view_component_reducible/msg"
+require_relative "view_component_reducible/adapter/base"
+require_relative "view_component_reducible/adapter/hidden_field"
+require_relative "view_component_reducible/adapter/session"
+require_relative "view_component_reducible/helpers"
+require_relative "view_component_reducible/state/schema"
+require_relative "view_component_reducible/state/dsl"
+require_relative "view_component_reducible/state/envelope"
+require_relative "view_component_reducible/component"
+require_relative "view_component_reducible/runtime"
+require_relative "view_component_reducible/dispatch"
+require_relative "view_component_reducible/dispatch_controller"
+require_relative "view_component_reducible/engine"
+require_relative "view_component_reducible/railtie"
+
+module ViewComponentReducible
+  class Error < StandardError; end
+
+  # @return [Hash{String=>Class}]
+  def self.registry
+    @registry ||= {}
+  end
+
+  # @param component_klass [Class]
+  # @return [void]
+  def self.register(component_klass)
+    registry[component_klass.vcr_id] = component_klass
+  end
+
+  # @return [ViewComponentReducible::Configuration]
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  # @yield [ViewComponentReducible::Configuration]
+  # @return [void]
+  def self.configure
+    yield config
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: view_component_reducible
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- manabeai
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  view_component_reducible brings reducer-style (TEA-inspired) state transitions
+  to Rails ViewComponent. Server-driven, HTTP-based, no WebSocket required.
+email:
+- matsu.devtool@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/view_component_reducible.rb
+- lib/view_component_reducible/adapter/base.rb
+- lib/view_component_reducible/adapter/hidden_field.rb
+- lib/view_component_reducible/adapter/session.rb
+- lib/view_component_reducible/component.rb
+- lib/view_component_reducible/configuration.rb
+- lib/view_component_reducible/dispatch.rb
+- lib/view_component_reducible/dispatch_controller.rb
+- lib/view_component_reducible/engine.rb
+- lib/view_component_reducible/helpers.rb
+- lib/view_component_reducible/msg.rb
+- lib/view_component_reducible/railtie.rb
+- lib/view_component_reducible/runtime.rb
+- lib/view_component_reducible/state/dsl.rb
+- lib/view_component_reducible/state/envelope.rb
+- lib/view_component_reducible/state/schema.rb
+- lib/view_component_reducible/version.rb
+homepage: https://github.com/manabeai/view_component_reducible
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/manabeai/view_component_reducible
+  source_code_uri: https://github.com/manabeai/view_component_reducible
+  changelog_uri: https://github.com/manabeai/view_component_reducible/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Reducer-based state transitions for Rails ViewComponent
+test_files: []