react-email-rails 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4755984b895a6aa5f220079065da541f8b8da23dc905095fb5cae48471fb2096
-  data.tar.gz: 66568a9bd36727d453904f765b2eb73b3aff4b8335b59de57d34933f1e4a4b8a
+  metadata.gz: cf2e6b94aa19f4ccec30037d5eefb38b1b98ba2f070ede1a89c99818e47b2eec
+  data.tar.gz: 26710f44d94a84d1df7a73a0759973c37fc9b3ec031c143ae902aed890ebb2d2
 SHA512:
-  metadata.gz: d5b407fd84acd1a1f162fe412f5d1ee611a0fdd095a2923b2a38ef2c63e366023a513fa26c09453fbbc1c9821c3681bb2838713dfdcf463dd8c767cdc5375b5c
-  data.tar.gz: 81f890f4900c9dae7631073bb68b66941642456fc895a81a3a78620f7e719df506ead6dcf5fddc38ab746182f544054f243f111968839e99e512e1a89eb0fe4b
+  metadata.gz: 911446dcf37e32e420bef4e0f02cdf8c30c6076854dba593737ae552138e139473f355d1ef14328bf50cf77943e5b376e82300185b8d23ea34fb41a1a3deaaaf
+  data.tar.gz: 708ac8a7339f5133be74caccce59a1f30dc890f6da95adeb5385a5117b894295fd8e3e5748a50e8a46d0cdd6bcc1abc6d3943abf9bf146dd2b57163c3d0c94a5

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.8.0
+
+- **Breaking:** Remove `@react-email/editor` document rendering to focus the library on component-based Action Mailer emails. `ReactEmailRails.compose`, `ReactEmailRails.parse`, the `documents` Vite plugin option, and the `react-email-rails/document` module are gone, along with the `@react-email/editor`, `@tiptap/core`, `@tiptap/html`, `happy-dom`, and `marked` optional peer dependencies.
+- **Breaking:** `on_render_error` callbacks and the `render.react-email-rails` instrumentation payload no longer include `kind:` (every render is a component email again); `RenderedEmail` no longer has `warnings`.
+- Bump the render protocol to 4 (the renderer no longer accepts document or parse requests). The Ruby gem and npm package must be upgraded together, as before.
+
+## 0.7.0
+
+- Add development live-reloading for Action Mailer previews. A development-only preview interceptor injects Vite's `@vite/client` into previews, and the `reactEmailRails()` plugin triggers a full reload when an email component changes, so the open preview refreshes on save. Configure the dev-server URL with `live_reload_url`, or set it to a falsy value to disable.
+
 ## 0.6.1
 
 - Fix `react:` rendering — and the `mailer`/`message` props — being skipped for actions that opt in through a class-level `default react: true` rather than a per-`mail` `react:` option. `mail` now resolves `react` (in any form: `true`, a component string, or a prop hash) from the mailer's `default`, a per-action `react: false` opts back out, and the internal `react`/`props`/`deep_merge` options never leak onto the message as email headers.

data/README.md

@@ -18,7 +18,6 @@ You get:
 - Vite-powered development rendering
 - A production renderer bundle built during `assets:precompile`
 - Optional persistent rendering for high-volume workers
-- Optional server-side rendering for `@react-email/editor` documents
 
 ## Status
 
@@ -30,8 +29,8 @@ The supported Ruby, Rails, Node, React, and Vite versions are tested in CI. Plea
 
 - [Requirements](#requirements)
 - [Installation](#installation)
-- [Your First Email](#your-first-email)
-- [How Rendering Works](#how-rendering-works)
+- [Quick Start](#quick-start)
+- [Rendering](#rendering)
 - [Usage](#usage)
 - [Configuration](#configuration)
 - [Deployment](#deployment)
@@ -100,7 +99,7 @@ export default defineConfig({
 })
 ```
 
-## Your First Email
+## Quick Start
 
 Generate a mailer and React Email component:
 
@@ -169,7 +168,7 @@ AccountMailer.with(account: current_account).welcome.deliver_later
 
 React Email also provides primitives like [`<Button>`, `<Heading>`, `<Tailwind>`, and more](https://react.email/docs/components/html).
 
-## How Rendering Works
+## Rendering
 
 In development, react-email-rails renders components through Vite's dev pipeline. Your email components get the same module resolution and transforms as the rest of your frontend.
 
@@ -177,6 +176,18 @@ In production, `assets:precompile` builds a server-side renderer bundle from you
 
 Every `react:` email renders HTML and plain text from the same component. If rendering fails, the email is not sent and `ReactEmailRails::RenderError` is raised.
 
+### Live-Reloading Previews
+
+In development, Action Mailer previews automatically reload themselves when you edit an email component. react-email-rails registers a [preview interceptor](https://api.rubyonrails.org/classes/ActionMailer/Base.html#class-ActionMailer::Base-label-Previewing+emails) that injects `@vite/client` into the preview, and the `reactEmailRails()` plugin broadcasts a full reload over Vite's websocket whenever a file under your emails directory changes.
+
+The `live_reload_url` defaults to Vite's `http://localhost:5173`, but you can point elsewhere if needed, or set it to a falsy value to disable live reload. (See [Configuration](#configuration))
+
+```ruby
+ReactEmailRails.configure do |config|
+  config.live_reload_url = "http://localhost:3036" # or nil or false to disable
+end
+```
+
 ## Usage
 
 ### Passing Props
@@ -459,12 +470,6 @@ export default function Welcome() {
 }
 ```
 
-### Editor Documents
-
-If your app uses [@react-email/editor](https://react.email/docs/editor) to let users compose emails visually, `ReactEmailRails.compose` can render stored editor documents on the server.
-
-See [Editor rendering](docs/editor.md) for setup and usage.
-
 ## Configuration
 
 Configuration lives in two places:
@@ -492,6 +497,7 @@ end
 | `render_process_max_requests` | `1_000` |
 | `on_render_error` | `nil` |
 | `deep_merge_shared_props` | `false` |
+| `live_reload_url` | `http://localhost:5173` |
 
 ### Prop Transformation
 
@@ -567,11 +573,11 @@ ReactEmailRails.configure do |config|
 end
 ```
 
-The callback receives the error plus render context such as `kind:` and `component:`.
+The callback receives the error plus render context such as `component:`.
 
 ### Instrumentation
 
-Every render emits `render.react-email-rails` through [ActiveSupport::Notifications](https://guides.rubyonrails.org/active_support_instrumentation.html). Email payloads include `kind`, `component`, and successful HTML size in `html_bytes`.
+Every render emits `render.react-email-rails` through [ActiveSupport::Notifications](https://guides.rubyonrails.org/active_support_instrumentation.html). Payloads include `component` and successful HTML size in `html_bytes`.
 
 ```ruby
 ActiveSupport::Notifications.subscribe("render.react-email-rails") do |event|
@@ -606,7 +612,6 @@ Server, preview, dependency optimization, and build output settings stay owned b
 | `emails.path` | `"app/javascript/emails"` | Directory containing email components |
 | `emails.extension` | `[".tsx", ".jsx"]` | Component extension, or an array of extensions |
 | `emails.ignore` | `["**/_*", "**/_*/**"]` | Glob patterns ignored under `emails.path` |
-| `documents` | `false` | Optional `@react-email/editor` document renderer discovery; see [Editor rendering](docs/editor.md) |
 | `standalone` | `true` | Inline production renderer bundle dependencies |
 | `vite` | `{}` | Extra email-only Vite config for compilation and resolution |
 
@@ -674,7 +679,7 @@ Production deploys should run the normal Rails asset task:
 bin/rails assets:precompile
 ```
 
-react-email-rails hooks `react_email_rails:build` into `assets:precompile`. The build task loads `reactEmailRails()` options from your Vite config and writes `tmp/react-email-rails/emails.js` with the email component registry. If [Editor rendering](docs/editor.md) is enabled, the bundle also includes document renderers.
+react-email-rails hooks `react_email_rails:build` into `assets:precompile`. The build task loads `reactEmailRails()` options from your Vite config and writes `tmp/react-email-rails/emails.js` with the email component registry.
 
 You can run the renderer build directly:
 
@@ -686,7 +691,7 @@ Production rendering requires that bundle. If it is missing, rendering raises `R
 
 Set `SKIP_REACT_EMAIL_RAILS_BUILD=1` to skip the automatic asset hook. Directly running `bin/rails react_email_rails:build` always attempts the build.
 
-The npm package, Vite, React, and `@react-email/render` must be available when Rails runs `assets:precompile`. If [Editor rendering](docs/editor.md) is enabled, its peer dependencies must be available too.
+The npm package, Vite, React, and `@react-email/render` must be available when Rails runs `assets:precompile`.
 
 The Ruby gem and npm package must stay on the same version. A protocol/version handshake catches mismatched installs and raises an actionable `ReactEmailRails::RenderError`.
 

data/SECURITY.md

@@ -3,7 +3,3 @@
 Please report security issues privately by emailing hi@supertape.com.
 
 Do not open a public GitHub issue for suspected vulnerabilities. Include the affected version, a minimal reproduction when possible, and any relevant deployment details.
-
-## Rendering editor documents
-
-`ReactEmailRails.compose` renders an `@react-email/editor` document (Tiptap/ProseMirror JSON) server-side. Treat that document as untrusted input: it is typically authored in a visual editor and stored, then rendered later. The renderer only dispatches to the extensions you register for that document type, and React Email escapes rendered output, but URL and asset sanitization inside your custom extensions (links, image sources, button hrefs) remains your application's responsibility. Validate or sanitize those values where you build extensions or transform the document.

data/lib/generators/react_email_rails/email_generator.rb

@@ -139,7 +139,6 @@ class ReactEmailRails::Generators::EmailGenerator < Rails::Generators::NamedBase
     ].find { |path| File.exist?(File.join(destination_root, path)) }
   end
 
-  # The reactEmailRails({ ... }) plugin call, up to the option key being scanned for.
   PLUGIN_OPENING = /reactEmailRails\s*\(\s*\{.*?/m
 
   def emails_path_from_vite_config

data/lib/generators/react_email_rails/vite_config_files.rb

@@ -2,7 +2,6 @@ module ReactEmailRails; end
 module ReactEmailRails::Generators; end
 
 module ReactEmailRails::Generators
-  # Candidate Vite config filenames in precedence order; shared by both generators.
   VITE_CONFIG_FILES = [
     "vite.config.ts",
     "vite.config.mts",

data/lib/react_email_rails/action_mailer.rb

@@ -1,7 +1,6 @@
 module ReactEmailRails::ActionMailer
   extend(ActiveSupport::Concern)
 
-  # `react_email_share` kwargs reserved for `before_action` filtering, not prop data.
   SHARED_FILTER_OPTIONS = [:if, :unless, :only, :except].freeze
 
   prepended do

data/lib/react_email_rails/configuration.rb

@@ -1,5 +1,4 @@
 class ReactEmailRails::Configuration
-  # Must match OUT_DIR/BUNDLE_FILE in vite/src/index.ts (check_version_sync.rb asserts it).
   BUNDLE_PATH = "tmp/react-email-rails/emails.js"
   BUILD_BIN = "node_modules/.bin/react-email-rails-build"
   CONFIG_BIN = "node_modules/.bin/react-email-rails-config"
@@ -7,6 +6,7 @@ class ReactEmailRails::Configuration
 
   DEFAULT_RENDER_TIMEOUT = 10
   DEFAULT_RENDER_PROCESS_MAX_REQUESTS = 1_000
+  DEFAULT_LIVE_RELOAD_URL = "http://localhost:5173"
 
   RENDER_MODES = {
     subprocess: ReactEmailRails::RenderModes::Subprocess,
@@ -35,6 +35,7 @@ class ReactEmailRails::Configuration
     :transform_props,
     :on_render_error,
     :deep_merge_shared_props,
+    :live_reload_url,
   )
 
   attr_reader(
@@ -54,10 +55,17 @@ class ReactEmailRails::Configuration
         config.transform_props = :lower_camel
         config.on_render_error = nil
         config.deep_merge_shared_props = false
+        config.live_reload_url = DEFAULT_LIVE_RELOAD_URL
       end
     end
   end
 
+  def resolve_live_reload_url
+    return if live_reload_url.blank?
+
+    live_reload_url.to_s.chomp("/")
+  end
+
   def render_mode=(value)
     if (value.is_a?(Symbol) || value.is_a?(String)) && !RENDER_MODES.key?(value.to_sym)
       raise(ArgumentError, "Unknown react-email-rails render mode: #{value.inspect}")
@@ -88,8 +96,6 @@ class ReactEmailRails::Configuration
     end
   end
 
-  # A callable render_options is instance_exec'd against `context` (the mailer) when given,
-  # so it can use per-mail helpers; otherwise it's called or returned as-is.
   def resolve_render_options(context = nil)
     value =
       if render_options.respond_to?(:call) && context

data/lib/react_email_rails/preview_live_reload.rb

@@ -0,0 +1,33 @@
+class ReactEmailRails::PreviewLiveReload
+  SCRIPT_TEMPLATE = %(<script type="module" src="%s/@vite/client"></script>)
+  BODY_CLOSE = %r{</body>}i
+
+  class << self
+    def previewing_email(message)
+      url = ReactEmailRails.configuration.resolve_live_reload_url
+      return unless url
+
+      part = html_part(message)
+      return unless part
+
+      part.body = inject(part.body.decoded, url)
+    end
+
+    private
+
+    def html_part(message)
+      return message.html_part if message.html_part
+      return message if message.mime_type == "text/html"
+
+      nil
+    end
+
+    def inject(html, url)
+      snippet = format(SCRIPT_TEMPLATE, url)
+      return html if html.include?(snippet)
+      return "#{html}#{snippet}" unless BODY_CLOSE.match?(html)
+
+      html.sub(BODY_CLOSE) { |tag| "#{snippet}#{tag}" }
+    end
+  end
+end

data/lib/react_email_rails/props_resolver.rb

@@ -1,6 +1,5 @@
 class ReactEmailRails::PropsResolver
   INTERNAL_ASSIGN_PREFIX = "_"
-  # Some Action Mailer framework assigns do not use the internal `_` prefix.
   RESERVED_ASSIGNS = ["params", "rendered_format"].freeze
 
   def initialize(mailer)
@@ -34,7 +33,6 @@ class ReactEmailRails::PropsResolver
   end
 
   def assign_props
-    # `react: true` infers the component; instance vars become props only when the mailer opts in.
     return {} unless mailer.class.react_email_use_instance_props
 
     mailer.instance_variables.each_with_object({}) do |ivar, props|

data/lib/react_email_rails/railtie.rb

@@ -2,6 +2,7 @@ class ReactEmailRails::Railtie < Rails::Railtie
   initializer("react-email-rails.action_mailer") do
     ActiveSupport.on_load(:action_mailer) do
       prepend(ReactEmailRails::ActionMailer)
+      register_preview_interceptor(ReactEmailRails::PreviewLiveReload) if Rails.env.development?
     end
   end
 

data/lib/react_email_rails/render_modes/persistent/command_runner.rb

@@ -1,5 +1,4 @@
 class ReactEmailRails::RenderModes::Persistent::CommandRunner
-  # Eager (not lazy) so concurrent first renders can't each create separate Mutexes.
   @mutex = Mutex.new
 
   class << self
@@ -30,8 +29,6 @@ class ReactEmailRails::RenderModes::Persistent::CommandRunner
       end
     end
 
-    # A forked child inherits the parent's Servers and their open pipes; sharing those pipes
-    # interleaves requests across processes, so drop them without killing the parent's process.
     def reset_after_fork
       return if @owner_pid == Process.pid && @servers
 

data/lib/react_email_rails/render_modes/persistent/server.rb

@@ -1,7 +1,6 @@
 class ReactEmailRails::RenderModes::Persistent::Server
   STDERR_LIMIT = 8 * 1024
 
-  # Minimal Process::Status stand-in; only #success? is ever read.
   Status = Data.define(:success) do
     def success? = success
   end
@@ -38,7 +37,6 @@ class ReactEmailRails::RenderModes::Persistent::Server
     release_io
   end
 
-  # Release this process's copy of an inherited child's pipes without signalling the parent-owned process.
   def abandon
     release_io
   rescue IOError
@@ -47,14 +45,12 @@ class ReactEmailRails::RenderModes::Persistent::Server
 
   private
 
-  # Shared by stop (which also kills the process) and abandon (which must not).
   def release_io
     [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
     @stdin = @stdout = @stderr = @wait_thread = @stderr_reader = nil
     @stdout_buffer.clear
   end
 
-  # Run under the mutex; on a broken pipe, stop and retry once (the child respawns).
   def with_retry_on_broken_pipe(&block)
     @mutex.synchronize(&block)
   rescue Errno::EPIPE, IOError
@@ -72,8 +68,6 @@ class ReactEmailRails::RenderModes::Persistent::Server
     response = request(input, timeout:)
     return failure(response["error"].to_s.presence || "render process failed") unless response["ok"]
 
-    # Re-serialize into the same Result.stdout contract the subprocess produces, so
-    # Subprocess#run parses and validates every render uniformly.
     success(JSON.generate(
       {
         protocolVersion: response["protocolVersion"],
@@ -81,8 +75,6 @@ class ReactEmailRails::RenderModes::Persistent::Server
       }.tap do |body|
         body[:html] = response["html"] if response.key?("html")
         body[:text] = response["text"] if response.key?("text")
-        body[:warnings] = response["warnings"] if response.key?("warnings")
-        body[:document] = response["document"] if response.key?("document")
       end,
     ))
   rescue JSON::ParserError => e

data/lib/react_email_rails/render_modes/subprocess.rb

@@ -8,12 +8,9 @@ class ReactEmailRails::RenderModes::Subprocess
     end
   end
 
-  # `label` names the render in error messages. `response` reads the reply as `:email`
-  # (RenderedEmail, for render/compose) or `:document` (parsed document, for parse).
-  def initialize(payload:, label:, response: :email)
+  def initialize(payload:, label:)
     @payload = payload
     @label = label
-    @response = response
   end
 
   def render
@@ -22,7 +19,7 @@ class ReactEmailRails::RenderModes::Subprocess
 
   private
 
-  attr_reader(:payload, :label, :response)
+  attr_reader(:payload, :label)
 
   def run
     result = capture(payload_json)
@@ -30,7 +27,7 @@ class ReactEmailRails::RenderModes::Subprocess
 
     body = JSON.parse(result.stdout)
     validate_metadata!(body)
-    build_result(body)
+    build_rendered_email(body)
   rescue JSON::ParserError => e
     raise(render_error("render process returned invalid JSON: #{e.message}"))
   rescue KeyError => e
@@ -44,7 +41,6 @@ class ReactEmailRails::RenderModes::Subprocess
     end
   end
 
-  # Shared by Persistent#capture so the transport-error messages live in one place.
   def with_capture_rescues
     yield
   rescue Timeout::Error
@@ -89,32 +85,12 @@ class ReactEmailRails::RenderModes::Subprocess
     raise(render_error(ReactEmailRails::RenderProtocol.mismatch_message(body)))
   end
 
-  def build_result(body)
-    response == :document ? build_document(body) : build_rendered_email(body)
-  end
-
   def build_rendered_email(body)
     raise(KeyError.new(key: "html")) unless body.key?("html")
     raise(render_error("render process returned an invalid response: html must be a string")) unless body["html"].is_a?(String)
     raise(render_error("render process returned an invalid response: text must be a string")) if body.key?("text") && !body["text"].is_a?(String)
 
-    ReactEmailRails::RenderedEmail.new(html: body.fetch("html"), text: body["text"].to_s, warnings: warnings_from(body))
-  end
-
-  def build_document(body)
-    raise(KeyError.new(key: "document")) unless body.key?("document")
-
-    document = body.fetch("document")
-    raise(render_error("parse process returned an invalid response: document must be an object")) unless document.is_a?(Hash)
-
-    document
-  end
-
-  def warnings_from(body)
-    warnings = body["warnings"]
-    return [] unless warnings.is_a?(Array)
-
-    warnings.filter_map { |warning| warning.transform_keys(&:to_sym) if warning.is_a?(Hash) }
+    ReactEmailRails::RenderedEmail.new(html: body.fetch("html"), text: body["text"].to_s)
   end
 
   def render_error(message)

data/lib/react_email_rails/render_protocol.rb

@@ -1,12 +1,11 @@
 require("json")
 
 module ReactEmailRails
-  RENDER_PROTOCOL_VERSION = 3
+  RENDER_PROTOCOL_VERSION = 4
 
   module RenderProtocol
     extend(self)
 
-    # Callers keep their own rescue to also cover failures obtaining the result.
     def healthy_result?(result)
       result.status.success? && compatible_response?(JSON.parse(result.stdout))
     end

data/lib/react_email_rails/rendered_email.rb

@@ -1,8 +1,3 @@
 module ReactEmailRails
-  # `warnings` are non-fatal (document nodes nothing rendered); empty for component renders.
-  RenderedEmail = Data.define(:html, :text, :warnings) do
-    def initialize(html:, text:, warnings: [])
-      super
-    end
-  end
+  RenderedEmail = Data.define(:html, :text)
 end

data/lib/react_email_rails/shared_props.rb

@@ -1,5 +1,3 @@
-# Collects props registered with `react_email_share` and merges them beneath the
-# per-mail props, which win on conflict. Mirrors inertia-rails shared data.
 class ReactEmailRails::SharedProps
   IVAR = :@_react_email_shared
 
@@ -7,8 +5,6 @@ class ReactEmailRails::SharedProps
     @mailer = mailer
   end
 
-  # Returns `props` untouched when nothing is shared, so non-Hash inputs (e.g.
-  # serializers) still flow straight through to serialization.
   def merge_into(props, deep_merge:)
     shared = to_h
     return props if shared.empty?
@@ -32,8 +28,6 @@ class ReactEmailRails::SharedProps
     mailer.instance_variable_get(IVAR) || []
   end
 
-  # An entry is either a static Hash or a block evaluated at render time. Callable
-  # values inside a Hash are evaluated too, so `unread_count: -> { ... }` works.
   def resolve(entry)
     hash = entry.respond_to?(:call) ? mailer.instance_exec(&entry) : entry
 

data/lib/react_email_rails/version.rb

@@ -1,3 +1,3 @@
 module ReactEmailRails
-  VERSION = "0.6.1"
+  VERSION = "0.8.0"
 end

data/lib/react_email_rails.rb

@@ -27,6 +27,7 @@ require_relative("react_email_rails/tasks")
 require_relative("react_email_rails/props_resolver")
 require_relative("react_email_rails/shared_props")
 require_relative("react_email_rails/mailer_context")
+require_relative("react_email_rails/preview_live_reload")
 require_relative("react_email_rails/railtie")
 
 module ReactEmailRails
@@ -43,31 +44,12 @@ module ReactEmailRails
       payload = { component:, props: serialized_props(props) }
       payload[:renderOptions] = render_options if render_options.present?
 
-      perform(payload:, label: component, kind: "email", component:)
-    end
-
-    # The document is sent verbatim (keys are structural); only context is key-transformed, like props.
-    def compose(type:, document:, context: {}, preview: nil)
-      payload = {
-        kind: "document",
-        type:,
-        document: document.as_json,
-        context: serialized_props(context),
-        preview:,
-      }
-
-      perform(payload:, label: type, kind: "document", type:)
-    end
-
-    # Returns an editor document Hash, built via the renderer's extensions. Pass exactly one of `html:`/`markdown:`.
-    def parse(type:, html: nil, markdown: nil, context: {})
-      payload = {
-        kind: "parse",
-        type:,
-        context: serialized_props(context),
-      }.merge(parse_source(html:, markdown:))
-
-      perform(payload:, label: type, response: :document, kind: "parse", type:)
+      instrument(component:) do
+        configuration.resolved_render_mode.new(payload:, label: component).render
+      end
+    rescue ReactEmailRails::RenderError => e
+      configuration.on_render_error&.call(e, component:)
+      raise
     end
 
     def healthy?
@@ -81,39 +63,13 @@ module ReactEmailRails
 
     private
 
-    def perform(payload:, label:, response: :email, **metadata)
-      instrument(**metadata) do
-        configuration.resolved_render_mode.new(payload:, label:, response:).render
-      end
-    rescue ReactEmailRails::RenderError => e
-      configuration.on_render_error&.call(e, **metadata)
-      raise
-    end
-
-    # Markdown is converted renderer-side, not here; both inputs are sent as-is.
-    def parse_source(html:, markdown:)
-      if !html.nil? && !markdown.nil?
-        raise(ArgumentError, "ReactEmailRails.parse accepts only one of html: or markdown:")
-      end
-
-      return { html: html.to_s } unless html.nil?
-      return { markdown: markdown.to_s } unless markdown.nil?
-
-      raise(ArgumentError, "ReactEmailRails.parse requires html: or markdown:")
-    end
-
     def serialized_props(value)
       configuration.send(:serialize_props, value)
     end
 
-    def instrument(**metadata)
-      ActiveSupport::Notifications.instrument("render.react-email-rails", **metadata) do |payload|
-        yield.tap do |result|
-          next unless result.respond_to?(:html)
-
-          payload[:html_bytes] = result.html.bytesize
-          payload[:warnings] = result.warnings if result.warnings.present?
-        end
+    def instrument(component:)
+      ActiveSupport::Notifications.instrument("render.react-email-rails", component:) do |payload|
+        yield.tap { |result| payload[:html_bytes] = result.html.bytesize }
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-email-rails
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Supertape
@@ -154,6 +154,7 @@ files:
 - lib/react_email_rails/action_mailer.rb
 - lib/react_email_rails/configuration.rb
 - lib/react_email_rails/mailer_context.rb
+- lib/react_email_rails/preview_live_reload.rb
 - lib/react_email_rails/props_resolver.rb
 - lib/react_email_rails/railtie.rb
 - lib/react_email_rails/render_error.rb