module Turbo::Broadcastable

def broadcast_action(action, target: broadcast_target_default, **rendering)

Same as #broadcast_action_to, but the designated stream is automatically set to the current model. 
def broadcast_action(action, target: broadcast_target_default, **rendering)
  broadcast_action_to self, action: action, target: target, **rendering
end

def broadcast_action_later(action:, target: broadcast_target_default, **rendering)

Same as #broadcast_action_later_to, but the designated stream is automatically set to the current model. 
def broadcast_action_later(action:, target: broadcast_target_default, **rendering)
  broadcast_action_later_to self, action: action, target: target, **rendering
end

def broadcast_action_later_to(*streamables, action:, target: broadcast_target_default, **rendering)

Same as broadcast_action_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_action_later_to(*streamables, action:, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_action_later_to(*streamables, action: action, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_action_to(*streamables, action:, target: broadcast_target_default, **rendering)

clearance.broadcast_action_to examiner.identity, :clearances, action: :prepend, target: "clearances"
# to the stream named "identity:2:clearances"
# Sends

Broadcast a named action, allowing for dynamic dispatch, instead of using the concrete action methods. Examples: 
def broadcast_action_to(*streamables, action:, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_action_to(*streamables, action: action, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_after_to(*streamables, target:, **rendering)

partial: "clearances/other_partial", locals: { a: 1 }
clearance.broadcast_after_to examiner.identity, :clearances, target: "clearance_5",
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_after_to examiner.identity, :clearances, target: "clearance_5"
# to the stream named "identity:2:clearances"
# Sends

appending named arguments to the call. Examples:
for subscribers of the stream name identified by the passed streamables. The rendering parameters can be set by
Insert a rendering of this broadcastable model after the target identified by it's dom id passed as target 
def broadcast_after_to(*streamables, target:, **rendering)
  Turbo::StreamsChannel.broadcast_after_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_append(target: broadcast_target_default, **rendering)

Same as #broadcast_append_to, but the designated stream is automatically set to the current model. 
def broadcast_append(target: broadcast_target_default, **rendering)
  broadcast_append_to self, target: target, **rendering
end

def broadcast_append_later(target: broadcast_target_default, **rendering)

Same as #broadcast_append_later_to, but the designated stream is automatically set to the current model. 
def broadcast_append_later(target: broadcast_target_default, **rendering)
  broadcast_append_later_to self, target: target, **rendering
end

def broadcast_append_later_to(*streamables, target: broadcast_target_default, **rendering)

Same as broadcast_append_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_append_later_to(*streamables, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_append_later_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_append_to(*streamables, target: broadcast_target_default, **rendering)

partial: "clearances/other_partial", locals: { a: 1 }
clearance.broadcast_append_to examiner.identity, :clearances, target: "clearances",
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_append_to examiner.identity, :clearances, target: "clearances"
# to the stream named "identity:2:clearances"
# Sends

appending named arguments to the call. Examples:
for subscribers of the stream name identified by the passed streamables. The rendering parameters can be set by
Append a rendering of this broadcastable model to the target identified by it's dom id passed as target 
def broadcast_append_to(*streamables, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_append_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_before_to(*streamables, target:, **rendering)

partial: "clearances/other_partial", locals: { a: 1 }
clearance.broadcast_before_to examiner.identity, :clearances, target: "clearance_5",
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_before_to examiner.identity, :clearances, target: "clearance_5"
# to the stream named "identity:2:clearances"
# Sends

appending named arguments to the call. Examples:
for subscribers of the stream name identified by the passed streamables. The rendering parameters can be set by
Insert a rendering of this broadcastable model before the target identified by it's dom id passed as target 
def broadcast_before_to(*streamables, target:, **rendering)
  Turbo::StreamsChannel.broadcast_before_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_prepend(target: broadcast_target_default, **rendering)

Same as #broadcast_prepend_to, but the designated stream is automatically set to the current model. 
def broadcast_prepend(target: broadcast_target_default, **rendering)
  broadcast_prepend_to self, target: target, **rendering
end

def broadcast_prepend_later(target: broadcast_target_default, **rendering)

Same as #broadcast_prepend_later_to, but the designated stream is automatically set to the current model. 
def broadcast_prepend_later(target: broadcast_target_default, **rendering)
  broadcast_prepend_later_to self, target: target, **rendering
end

def broadcast_prepend_later_to(*streamables, target: broadcast_target_default, **rendering)

Same as broadcast_prepend_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_prepend_later_to(*streamables, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_prepend_later_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_prepend_to(*streamables, target: broadcast_target_default, **rendering)

partial: "clearances/other_partial", locals: { a: 1 }
clearance.broadcast_prepend_to examiner.identity, :clearances, target: "clearances",
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_prepend_to examiner.identity, :clearances, target: "clearances"
# to the stream named "identity:2:clearances"
# Sends

appending named arguments to the call. Examples:
for subscribers of the stream name identified by the passed streamables. The rendering parameters can be set by
Prepend a rendering of this broadcastable model to the target identified by it's dom id passed as target 
def broadcast_prepend_to(*streamables, target: broadcast_target_default, **rendering)
  Turbo::StreamsChannel.broadcast_prepend_to(*streamables, target: target, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_remove

Same as #broadcast_remove_to, but the designated stream is automatically set to the current model. 
def broadcast_remove
  broadcast_remove_to self
end

def broadcast_remove_to(*streamables, target: self)

clearance.broadcast_remove_to examiner.identity, :clearances
# Sends to the stream named "identity:2:clearances"

Example:
Remove this broadcastable model from the dom for subscribers of the stream name identified by the passed streamables. 
def broadcast_remove_to(*streamables, target: self)
  Turbo::StreamsChannel.broadcast_remove_to(*streamables, target: target)
end

def broadcast_render(**rendering)

be using `broadcast_render_later`, unless you specifically know why synchronous rendering is needed.
desireable for model callbacks, certainly not if those callbacks are inside of a transaction. Most of the time you should
Note that rendering inline via this method will cause template rendering to happen synchronously. That is usually not

...to the stream named "entry:5".




Sends:

<%= turbo_stream.append "entries", entry if entry.active? %>

<%= turbo_stream.remove entry %>
# Template: entries/_entry.turbo_stream.erb

Render a turbo stream template with this broadcastable model passed as the local variable. Example: 
def broadcast_render(**rendering)
  broadcast_render_to self, **rendering
end

def broadcast_render_later(**rendering)

Same as broadcast_action_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_render_later(**rendering)
  broadcast_render_later_to self, **rendering
end

def broadcast_render_later_to(*streamables, **rendering)

streamables.
Same as broadcast_render_later but run with the added option of naming the stream using the passed 
def broadcast_render_later_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_render_later_to(*streamables, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_render_to(*streamables, **rendering)

be using `broadcast_render_later_to`, unless you specifically know why synchronous rendering is needed.
desireable for model callbacks, certainly not if those callbacks are inside of a transaction. Most of the time you should
Note that rendering inline via this method will cause template rendering to happen synchronously. That is usually not

streamables.
Same as broadcast_render but run with the added option of naming the stream using the passed 
def broadcast_render_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_render_to(*streamables, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_rendering_with_defaults(options) 

def broadcast_rendering_with_defaults(options)
  options.tap do |o|
    # Add the current instance into the locals with the element name (which is the un-namespaced name)
    # as the key. This parallels how the ActionView::ObjectRenderer would create a local variable.
    o[:locals] = (o[:locals] || {}).reverse_merge!(model_name.element.to_sym => self)
    # if the html option is passed in it will skip setting a partial from #to_partial_path
    unless o.include?(:html)
      o[:partial] ||= to_partial_path
    end
  end
end

def broadcast_replace(**rendering)

Same as #broadcast_replace_to, but the designated stream is automatically set to the current model. 
def broadcast_replace(**rendering)
  broadcast_replace_to self, **rendering
end

def broadcast_replace_later(**rendering)

Same as #broadcast_replace_later_to, but the designated stream is automatically set to the current model. 
def broadcast_replace_later(**rendering)
  broadcast_replace_later_to self, **rendering
end

def broadcast_replace_later_to(*streamables, **rendering)

Same as broadcast_replace_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_replace_later_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_replace_later_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_replace_to(*streamables, **rendering)

clearance.broadcast_replace_to examiner.identity, :clearances, partial: "clearances/other_partial", locals: { a: 1 }
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_replace_to examiner.identity, :clearances
# to the stream named "identity:2:clearances"
# Sends

streamables. The rendering parameters can be set by appending named arguments to the call. Examples:
Replace this broadcastable model in the dom for subscribers of the stream name identified by the passed 
def broadcast_replace_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_replace_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_target_default 

def broadcast_target_default
  self.class.broadcast_target_default
end

def broadcast_update(**rendering)

Same as #broadcast_update_to, but the designated stream is automatically set to the current model. 
def broadcast_update(**rendering)
  broadcast_update_to self, **rendering
end

def broadcast_update_later(**rendering)

Same as #broadcast_update_later_to, but the designated stream is automatically set to the current model. 
def broadcast_update_later(**rendering)
  broadcast_update_later_to self, **rendering
end

def broadcast_update_later_to(*streamables, **rendering)

Same as broadcast_update_to but run asynchronously via a Turbo::Streams::BroadcastJob. 
def broadcast_update_later_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_update_later_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering))
end

def broadcast_update_to(*streamables, **rendering)

clearance.broadcast_update_to examiner.identity, :clearances, partial: "clearances/other_partial", locals: { a: 1 }
# to the stream named "identity:2:clearances"
# Sends

clearance.broadcast_update_to examiner.identity, :clearances
# to the stream named "identity:2:clearances"
# Sends

streamables. The rendering parameters can be set by appending named arguments to the call. Examples:
Update this broadcastable model in the dom for subscribers of the stream name identified by the passed 
def broadcast_update_to(*streamables, **rendering)
  Turbo::StreamsChannel.broadcast_update_to(*streamables, target: self, **broadcast_rendering_with_defaults(rendering))
end