Turbo Laravel

https://turbo-laravel.com/docs
Admin
Turbo Laravel is a package that integrates Turbo with Laravel, enabling faster page loads and a more...
Tokens:19,477
Snippets:124
Trust Score:6.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Run Turbo Laravel Artisan Command

Source: https://turbo-laravel.com/docs/index

Executes the `turbo:install` Artisan command to set up Turbo.js in a Laravel project. This command adds the Turbo.js dependency and publishes necessary files.

```bash
php artisan turbo:install
```

--------------------------------

### Install Turbo Laravel via Composer

Source: https://turbo-laravel.com/docs/index

Installs the Turbo Laravel package using Composer, a dependency manager for PHP.

```bash
composer require hotwired-laravel/turbo-laravel
```

--------------------------------

### Example Kernel with TurboMiddleware

Source: https://turbo-laravel.com/docs/validation-response-redirects

Demonstrates how to correctly register the `TurboMiddleware` at the top of the web middleware stack in the `app/Http/Kernel.php` file.

```php
namespace App\Http;

use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel
{
    protected $middlewareGroups = [
        'web' => [
            \HotwiredLaravel\TurboLaravel\Http\Middleware\TurboMiddleware::class,
            // other middlewares...
        ],
    ];
}
```

--------------------------------

### Install New Turbo Laravel Package

Source: https://turbo-laravel.com/docs/upgrade

This Composer command installs the new version of the Turbo Laravel package, specifying version 2.0 or higher.

```Shell
composer require hotwired-laravel/turbo-laravel:^2.0
```

--------------------------------

### Update View Component References

Source: https://turbo-laravel.com/docs/upgrade

This command uses `find` and `sed` to update view component references from the old `x-turbo-*` format to the new `x-turbo::*` format across specified directories.

```Shell
find app resources tests -type f -exec sed -i 's/x-turbo-/x-turbo::/g' {} +
```

--------------------------------

### Turbo Stream with Before and String Content (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This example shows a concise way to use the `before()` shorthand method with a simple string as content. It targets a comment model and inserts the provided string directly.

```PHP
turbo_stream()->before($comment, __('Oh, hey!'));
```

--------------------------------

### Hotwire Native Redirect with Flash Message Example

Source: https://turbo-laravel.com/docs/hotwire-native

Shows the resulting URL when a flash message is included with a Hotwire Native redirect. The flash message is appended as a query parameter, allowing the native client to display it, for example, as a toast notification.

```URL
/recede_historical_location?status=Tray%20created.
```

--------------------------------

### Broadcast Append with TurboStream Facade

Source: https://turbo-laravel.com/docs/broadcasting

Broadcasts a 'Hello World' message to the 'notifications' target on the 'general' channel using the TurboStream Facade. This is a basic example of sending a Turbo Stream update.

```php
TurboStream::broadcastAppend(
    content: __('Hello World'),
    target: 'notifications',
    channel: 'general',
);
```

--------------------------------

### Target Multiple Elements with xAll Shorthands

Source: https://turbo-laravel.com/docs/turbo-streams

Provides examples of using shorthand methods like `appendAll`, `prependAll`, `updateAll`, `replaceAll`, `beforeAll`, `afterAll`, and `removeAll` to target multiple elements using CSS selectors.

```PHP
turbo_stream()->appendAll('.comment', 'Some content');
turbo_stream()->prependAll('.comment', 'Some content');
turbo_stream()->updateAll('.comment', 'Some content');
turbo_stream()->replaceAll('.comment', 'Some content');
turbo_stream()->beforeAll('.comment', 'Some content');
turbo_stream()->afterAll('.comment', 'Some content');
turbo_stream()->removeAll('.comment');
```

--------------------------------

### Update Namespaces with sed

Source: https://turbo-laravel.com/docs/upgrade

This command uses `find` and `sed` to recursively search for and replace the old Turbo Laravel namespace with the new one in specified directories. It's designed for macOS or Linux systems.

```Shell
find app config resources tests -type f -exec sed -i 's/Tonysm\\TurboLaravel/HotwiredLaravel\\TurboLaravel/g' {} +
```

--------------------------------

### Basic Turbo Stream HTML Structure

Source: https://turbo-laravel.com/docs/turbo-streams

This example shows the fundamental HTML structure of a Turbo Stream response. It includes the `<turbo-stream>` tag with an action (e.g., 'append') and a target element ID, containing a `<template>` with the content to be rendered.

```HTML
<turbo-stream action="append" target="comments">
    <template>
        <div id="comment_123">
            <p>Hello, World</p>
        </div>
    </template>
</turbo-stream>
```

--------------------------------

### Mimic Turbo Frame Requests with `fromTurboFrame()`

Source: https://turbo-laravel.com/docs/testing

This example shows how to simulate a request originating from a Turbo Frame using the `fromTurboFrame()` helper. It involves specifying the DOM ID of the frame and then making a POST request, asserting a redirect response.

```PHP
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function create_comment()
    {
        $article = Article::factory()->create();

        $this->fromTurboFrame(dom_id($article, 'create_comment'))
            ->post(route('articles.comments.store', $article), [...])
            ->assertRedirect();
    }
}
```

--------------------------------

### Turbo Stream with HtmlString Content (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This example shows how to use an instance of `Illuminate\Support\HtmlString` for Turbo Stream content. It renders a simple HTML div with a name variable, demonstrating explicit HTML content generation.

```PHP
use Illuminate\Support\Facades\Blade;
use Illuminate\Support\HtmlString;

turbo_stream()->append('statuses', new HtmlString(
    Blade::render('<div>Hello, {{ $name }}</div>', ['name' => 'Tony'])
));
```

--------------------------------

### Turbo Stream with String Content (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This example shows how to use the shorthand stream builders with a simple string as content. The `append()` method is used here to add a status message to the 'statuses' target element.

```PHP
turbo_stream()->append('statuses', __('Comment created!'));
```

--------------------------------

### Remove Old Turbo Laravel Package

Source: https://turbo-laravel.com/docs/upgrade

This Composer command removes the previous version of the Turbo Laravel package from the project.

```Shell
composer remove hotwired/turbo-laravel
```

--------------------------------

### Assert Redirect Types in Tests

Source: https://turbo-laravel.com/docs/testing

This example shows how to use `TestResponse` macros like `assertRedirectRecede()` to verify specific redirect behaviors in your tests. The `$with` argument allows asserting flashed messages in the query string.

```PHP
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creating_comments_from_native_recedes()
    {
        $post = Post::factory()->create();

        $this->assertCount(0, $post->comments);

        $this->hotwireNative()->post(route('posts.comments.store', $post), [
            'content' => 'Hello World',
        ])->assertRedirectRecede(['status' => __('Comment created.')]);

        $this->assertCount(1, $post->refresh()->comments);
        $this->assertEquals('Hello World', $post->comments->first()->content);
    }
}
```

--------------------------------

### Controller with Turbo Stream Flash Message

Source: https://turbo-laravel.com/docs/turbo-streams

An example controller method that utilizes Turbo Streams to display a flash message notification after a resource is deleted.

```PHP
class ChirpsController extends Controller
{
    public function destroy(Request $request, Chirp $chirp)
    {
        $this->authorize('delete', $chirp);

        $chirp->delete();

        if ($request->wantsTurboStream()) {
            return turbo_stream([
                turbo_stream($chirp),
                turbo_stream()->append('notifications', view('layouts.notification', [
                    'message' => __('Chirp deleted.'),
                ])),
            ]);
        }

        // ...
    }
}
```

--------------------------------

### Respond with Custom Turbo Stream View in Laravel

Source: https://turbo-laravel.com/docs/turbo-streams

This example shows how to extract Turbo Streams into a dedicated Blade view and respond with it. This approach helps keep controllers cleaner by delegating stream logic to views.

```PHP
return turbo_stream_view('comments.turbo.created_stream', [
    'comment' => $comment,
]);
```

--------------------------------

### Resolve Partials Path Using Custom Pattern or Closure

Source: https://turbo-laravel.com/docs/conventions

This example shows how to manually define the partials path pattern in Turbo Laravel. You can use a string pattern with placeholders like {singular} and {plural}, or a Closure that receives the model instance and returns the view path.

```PHP
<?php

namespace App\Providers;

use HotwiredLaravel\TurboLaravel\Facades\Turbo;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Turbo::resolvePartialsPathUsing('{plural}.partials.{singular}');

        // Or...

        Turbo::resolvePartialsPathUsing(fn ($model) => 'partials.{singular}');
    }
}
```

--------------------------------

### Detecting Turbo Frame Requests (PHP)

Source: https://turbo-laravel.com/docs/turbo-frames

Provides PHP code examples for detecting if an incoming HTTP request originated from a Turbo Frame using the `wasFromTurboFrame()` method on the request object. It also shows how to check for a specific Turbo Frame.

```php
if ($request->wasFromTurboFrame()) {
    // ...
}
```

```php
if ($request->wasFromTurboFrame(dom_id($post, 'create_comment'))) {
    // ...
}
```

--------------------------------

### Turbo Stream with Before and View Template (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This code illustrates using the `before()` shorthand method with an additional `view()` call to specify a partial for insertion. It targets a comment model and inserts a flash message partial.

```PHP
turbo_stream()
    ->before($comment)
    ->view('comments.partials.flash_message', [
        'message' => __('Comment created!'),
    ]);
```

--------------------------------

### Mimic Turbo Visits with `turbo()`

Source: https://turbo-laravel.com/docs/testing

This snippet demonstrates how to use the `turbo()` method from the `InteractsWithTurbo` trait to mimic a Turbo visit. It includes setting the `Accept` header to `text/vnd.turbo-stream.html` and making a POST request, asserting the response status and the creation of a comment.

```PHP
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creates_comments()
    {
        $post = Post::factory()->create();

        $this->assertCount(0, $post->comments);

        $this->turbo()->post(route('posts.comments.store', $post), [
            'content' => 'Hello World',
        ])->assertOk();

        $this->assertCount(1, $post->refresh()->comments);
        $this->assertEquals('Hello World', $post->comments->first()->content);
    }
}
```

--------------------------------

### Basic Turbo Frame

Source: https://turbo-laravel.com/docs/overview

Demonstrates the basic usage of a Turbo Frame, which allows for partial page updates. Content within the frame is updated when interactions occur inside it.

```html
<turbo-frame id="my_frame">
    <h1>Hello, World!</h1>

    <a href="/somewhere">Click me</a>
</turbo-frame>

```

--------------------------------

### Manually Build Turbo Stream with View (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This snippet demonstrates building a Turbo Stream response manually by specifying the target, action, and the view partial to render. It uses the `turbo_stream()` helper with chained methods like `target()`, `action()`, and `view()` to construct the stream.

```PHP
turbo_stream()
    ->target('comments')
    ->action('append')
    ->view('comments.partials.comment', ['comment' => $comment]);
```

--------------------------------

### Turbo Stream Shorthand Methods (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This showcases the various shorthand methods provided by Turbo Laravel for common Turbo Stream actions like append, prepend, before, after, replace, update, remove, and refresh. These methods simplify the process of generating stream responses.

```PHP
turbo_stream()->append($comment);
turbo_stream()->prepend($comment);
turbo_stream()->before($comment);
turbo_stream()->after($comment);
turbo_stream()->replace($comment);
turbo_stream()->update($comment);
turbo_stream()->remove($comment);
turbo_stream()->refresh();
```

--------------------------------

### Target Multiple Elements with targets() Method

Source: https://turbo-laravel.com/docs/turbo-streams

Shows how to specify multiple targets using a CSS selector by chaining the `targets()` method before defining the action and view.

```PHP
turbo_stream()
    ->targets('.comment')
    ->action('append')
    ->view('comments.partials.comment', ['comment' => $comment]);
```

--------------------------------

### Chaining Broadcast Methods with TurboStream Facade

Source: https://turbo-laravel.com/docs/broadcasting

Demonstrates chaining methods like `target()` and `to()` on the `PendingBroadcast` object returned by `broadcastAppend`. This provides a fluent interface for configuring broadcasts.

```php
TurboStream::broadcastAppend('Hello World')
    ->target('notifications')
    ->to('general');
```

--------------------------------

### Configure Refresh Behaviors with <x-turbo::refreshes-with>

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::refreshes-with> component allows simultaneous configuration of both refresh method and scroll behavior using meta tags.

```html
<x-turbo::refreshes-with method="morph" scroll="preserve" />
```

--------------------------------

### Service Provider Macro for Flash Message

Source: https://turbo-laravel.com/docs/turbo-streams

Demonstrates how to create a custom macro named `flash` for the `PendingTurboStreamResponse` class in the `AppServiceProvider` to simplify returning flash messages.

```PHP
class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        PendingTurboStreamResponse::macro('flash', function (string $message) {
            return $this->append('notifications', view('layouts.notification', [
                'message' => $message,
            ]));
        });
    }
}
```

--------------------------------

### Hotwire Native Redirect Helpers

Source: https://turbo-laravel.com/docs/hotwire-native

Provides a list of helper methods available from the `InteractsWithHotwireNativeNavigation` trait for controlling navigation behavior in Hotwire Native applications. These methods allow for specific actions like receding, resuming, or refreshing the current view.

```PHP
$this->recedeOrRedirectTo(string $url);
$this->resumeOrRedirectTo(string $url);
$this->refreshOrRedirectTo(string $url);
$this->recedeOrRedirectBack(string $fallbackUrl, array $options = []);
$this->resumeOrRedirectBack(string $fallbackUrl, array $options = []);
$this->refreshOrRedirectBack(string $fallbackUrl, array $options = []);
```

--------------------------------

### Use Partials Subfolder Pattern in Turbo Laravel

Source: https://turbo-laravel.com/docs/conventions

This code snippet demonstrates how to configure Turbo Laravel to use a specific subfolder pattern for partials, such as '{plural}.partials.{singular}'. This is done within the `AppServiceProvider`'s `boot` method.

```PHP
<?php

namespace App\Providers;

use HotwiredLaravel\TurboLaravel\Facades\Turbo;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Turbo::usePartialsSubfolderPattern();
    }
}
```

--------------------------------

### Configure Refresh Method with <x-turbo::refresh-method>

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::refresh-method> component allows configuration of how Turbo updates the document, supporting 'replace' or 'morph' methods.

```html
<x-turbo::refresh-method method="morph" />
```

--------------------------------

### Configure Broadcast Insertion Method

Source: https://turbo-laravel.com/docs/broadcasting

Shows how to configure the `$broadcasts` property as an array to specify the insertion method, such as 'prepend', for newly created models.

```php
class Comment extends Model
{
    use Broadcasts;

    protected $broadcasts = [
        'insertsBy' => 'prepend',
    ];
}
```

--------------------------------

### Available Broadcast Methods with TurboStream Facade

Source: https://turbo-laravel.com/docs/broadcasting

Lists the available methods on the TurboStream Facade for broadcasting different types of Turbo Stream actions. These methods abstract common operations like appending, prepending, updating, and removing elements.

```php
TurboStream::broadcastAppend();
TurboStream::broadcastPrepend();
TurboStream::broadcastBefore();
TurboStream::broadcastAfter();
TurboStream::broadcastUpdate();
TurboStream::broadcastReplace();
TurboStream::broadcastRemove();
TurboStream::broadcastRefresh();
```

--------------------------------

### Turbo Stream Update with Morph

Source: https://turbo-laravel.com/docs/turbo-streams

Demonstrates generating a Turbo Stream with the 'update' action and the `method="morph"` attribute using the `morph()` method for DOM morphing.

```PHP
turbo_stream()->update(dom_id($post, 'comments'), view('comments.partials.comment', [
    'comment' => $comment,
]))->morph();
```

--------------------------------

### Configuring PendingBroadcast with Closure

Source: https://turbo-laravel.com/docs/broadcasting

Shows how to configure the `PendingBroadcast` object generated by `turbo_stream()->broadcastTo()` by passing a closure. This allows for advanced configurations like broadcasting to others.

```php
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastTo('general', fn ($broadcast) => $broadcast->toOthers());
```

--------------------------------

### Exempt Page from Preview with <x-turbo::exempts-page-from-preview>

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::exempts-page-from-preview> component adds a meta tag to prevent Turbo from showing the page as a preview on regular navigation, reserving it for restoration visits.

```html
<x-turbo::exempts-page-from-preview />
```

--------------------------------

### Manual Page Refresh Broadcasting Implementation (PHP)

Source: https://turbo-laravel.com/docs/broadcasting

This snippet shows the equivalent of setting `$broadcastsRefreshes` by manually implementing the `booted` method to trigger `broadcastRefresh` on model events.

```php
use Illuminate\Broadcasting\Channel;

class Comment extends Model
{
    use Broadcasts;

    public static function booted()
    {
        static::created(function ($comment) {
            $comment->broadcastRefreshTo("comments")->later();
        });

        static::updated(function ($comment) {
            $comment->broadcastRefresh()->later();
        });

        static::deleted(function ($comment) {
            $comment->broadcastRefresh();
        });
    }
}
```

--------------------------------

### Assert Turbo Streams with Callbacks

Source: https://turbo-laravel.com/docs/testing

Assert specific details about returned Turbo Streams using the `assertTurboStream()` macro with a callback. This allows assertions on the number of streams, targets, actions, and HTML content.

```PHP
/** @test */
public function create_todos()
{
    $this->get(route('todos.store'))
        ->assertTurboStream(fn (AssertableTurboStream $turboStreams) => (
            $turboStreams->has(2)
            && $turboStreams->hasTurboStream(fn ($turboStream) => (
                $turboStream->where('target', 'flash_messages')
                            ->where('action', 'prepend')
                            ->see('Todo was successfully created!')
            ))
            && $turboStreams->hasTurboStream(fn ($turboStream) => (
                $turboStream->where('target', 'todos')
                            ->where('action', 'append')
                            ->see('Test the app')
            ))
        ));
}
```

--------------------------------

### Broadcasting to Presence Channel with turbo_stream()

Source: https://turbo-laravel.com/docs/broadcasting

Shows how to broadcast to a presence channel using `broadcastToPresenceChannel()` with the `turbo_stream()` response builder. This is suitable for real-time features involving multiple users.

```php
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastToPresenceChannel('chat.123', fn ($broadcast) => $broadcast->toOthers());
```

--------------------------------

### Use Turbo Stream Blade Component

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::stream> Blade component facilitates the rendering of Turbo Streams within Blade views. It accepts a target and an action, and can include partials for the stream's content.

```html
<x-turbo::stream :target="$post" action="update">
    @include('posts.partials.post', ['post' => $post])
<x-turbo::stream>
```

--------------------------------

### Turbo Stream Response Macro

Source: https://turbo-laravel.com/docs/helpers

The `response()->turboStream()` macro offers a convenient way to generate Turbo Stream responses, mirroring the functionality of the `turbo_stream()` helper function.

```PHP
response()->turboStream();
```

--------------------------------

### Available Model Broadcasting Methods

Source: https://turbo-laravel.com/docs/broadcasting

Lists the various methods available on a model after applying the `Broadcasts` trait for different Turbo Stream actions.

```php
$comment->broadcastAppend();
$comment->broadcastPrepend();
$comment->broadcastBefore('target_dom_id');
$comment->broadcastAfter('target_dom_id');
$comment->broadcastReplace();
$comment->broadcastUpdate();
$comment->broadcastRemove();
$comment->broadcastRefresh();
```

--------------------------------

### Lazy-Loading Turbo Frame

Source: https://turbo-laravel.com/docs/overview

Shows how to lazy-load content into a Turbo Frame by specifying a 'src' attribute. The frame's content is fetched and updated when it enters the DOM.

```html
<turbo-frame id="my_frame" src="{{ route('my.page') }}">
    <p>Loading...</p>
</turbo-frame>

```

--------------------------------

### Hook Broadcasts to Model Events

Source: https://turbo-laravel.com/docs/broadcasting

Demonstrates how to automatically trigger Turbo Stream broadcasts when model events like `created`, `updated`, or `deleted` occur by implementing the `booted` method.

```php
class Comment extends Model
{
    use Broadcasts;

    protected static function booted()
    {
        static::created(function (Comment $comment) {
            $comment->broadcastPrependTo($comment->post)->later();
        });

        static::updated(function (Comment $comment) {
            $comment->broadcastReplaceTo($comment->post)->later();
        });

        static::deleted(function (Comment $comment) {
            $comment->broadcastRemoveTo($comment->post)->later();
        });
    }
}
```

--------------------------------

### Custom Turbo Stream Action with Blade Component

Source: https://turbo-laravel.com/docs/turbo-streams

Demonstrates using the `<x-turbo::stream>` Blade component to perform custom actions, such as logging to the console. Custom actions are exclusively supported within Blade views.

```Blade
<x-turbo::stream action="console_log" value="Hello World" />
```

--------------------------------

### Handmade Broadcasting with turbo_stream() Response Builder

Source: https://turbo-laravel.com/docs/broadcasting

Introduces an alternative method for broadcasting Turbo Streams using the `turbo_stream()` response builder and its `broadcastTo()` method. This offers a more integrated approach within Laravel's response system.

```php
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastTo('general');
```

--------------------------------

### Turbo Stream View Response Macro

Source: https://turbo-laravel.com/docs/helpers

The `response()->turboStreamView()` macro provides a convenient method for generating Turbo Stream responses using separate Blade views, similar to the `turbo_stream_view()` helper function.

```PHP
response()->turboStreamView();
```

--------------------------------

### Handling Flash Messages with Hotwire Native Redirects

Source: https://turbo-laravel.com/docs/hotwire-native

Illustrates how flash messages are handled when using Hotwire Native redirects. Instead of being stored in the session, messages are appended to the query string of the redirect URL for the native client to process.

```PHP
use HotwiredLaravel\TurboLaravel\Http\Controllers\Concerns\InteractsWithHotwireNativeNavigation;

class TraysController extends Controller
{
    use InteractsWithHotwireNativeNavigation;

    public function store()
    {
        // Tray creation...

        return $this->recedeOrRedirectTo(route('trays.show', $tray))
            ->with('status', __('Tray created.'));
    }
}
```

--------------------------------

### Checking Hotwire Native Visit (Turbo Facade)

Source: https://turbo-laravel.com/docs/hotwire-native

Utilizes the Turbo Facade to determine if the current visit originated from a Hotwire Native client. This provides an alternative method for backend detection and conditional logic.

```PHP
use HotwiredLaravel\TurboLaravel\Facades\Turbo;

if (Turbo::isHotwireNativeVisit()) {
    // ...
}

```

--------------------------------

### Detect Request From Hotwire Native Client

Source: https://turbo-laravel.com/docs/helpers

The `request()->wasFromHotwireNative()` macro identifies requests originating from Hotwire Native clients by checking for 'Hotwire Native' in the User-Agent header.

```PHP
request()->wasFromHotwireNative();
```

--------------------------------

### Chaining Pending Broadcast Options

Source: https://turbo-laravel.com/docs/broadcasting

Illustrates chaining methods on the `PendingBroadcast` instance returned by broadcasting methods. This allows customization of the broadcast, such as specifying the target, view, recipient, or dispatching it as a background job.

```php
$comment->broadcastAppend()
    ->to($post)
    ->view('comments/_custom_view_partial', [
        'comment' => $comment,
        'post' => $post,
    ])
    ->toOthers() // Do not send to the current user...
    ->later(); // Don't send it now, dispatch a job to send in background instead...
```

--------------------------------

### Turbo Stream HTML Replace with Morph

Source: https://turbo-laravel.com/docs/turbo-streams

Shows the resulting HTML for a Turbo Stream action that uses 'replace' and the `method="morph"` attribute, indicating DOM morphing will be used.

```HTML
<turbo-stream action="replace" target="comments_post_123" method="morph">
    <template>...</template>
</turbo-stream>
```

--------------------------------

### Broadcast to Presence Channel

Source: https://turbo-laravel.com/docs/broadcasting

Demonstrates broadcasting to a presence channel using `toPresenceChannel()`. Presence channels are typically used for real-time features like chat or online user lists.

```php
TurboStream::broadcastAppend('Hello World')
    ->target('notifications')
    ->toPresenceChannel('user.123');
```

--------------------------------

### Turbo Stream Append Action

Source: https://turbo-laravel.com/docs/overview

Demonstrates a Turbo Stream action to append new content. The 'action="append"' targets an element with a specific ID, inserting the content from the template.

```html
<turbo-stream action="append" target="comments">
    <template>
        ...
    </template>
</turbo-stream>

```

--------------------------------

### Use Turbo Frame Blade Component

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::frame> Blade component simplifies the creation of Turbo Frames, automatically handling DOM ID generation from Eloquent models or strings. It also forwards standard Turbo Frame attributes.

```html
<x-turbo::frame :id="$post">
    <!-- Content -->
</x-turbo::frame>
```

```html
<x-turbo::frame :id="[$post, 'comments']">
    <!-- Content -->
</x-turbo::frame>
```

--------------------------------

### Lazy-Loading Turbo Frame with Visibility Trigger

Source: https://turbo-laravel.com/docs/overview

Enhances lazy-loading by adding a 'loading=lazy' attribute, ensuring the Turbo Frame's content is only fetched when the frame becomes visible within the viewport.

```html
<turbo-frame id="my_frame" src="{{ route('my.page') }}" loading="lazy">
    <p>Loading...</p>
</turbo-frame>

```

--------------------------------

### Controller Using Custom Flash Macro

Source: https://turbo-laravel.com/docs/turbo-streams

Refactored controller method that uses the custom `flash` macro to append a notification, making the code more concise.

```PHP
class ChirpsController extends Controller
{
    public function destroy(Request $request, Chirp $chirp)
    {
        $this->authorize('delete', $chirp);

        $chirp->delete();

        if ($request->wantsTurboStream()) {
            return turbo_stream([
                turbo_stream($chirp),
                turbo_stream()->append('notifications', view('layouts.notification', [
                    'message' => __('Chirp deleted.'),
                ])),
                turbo_stream()->flash(__('Chirp deleted.')),
            ]);
        }

        // ...
    }
}
```

--------------------------------

### Basic Turbo Frame with Blade

Source: https://turbo-laravel.com/docs/turbo-frames

Demonstrates the basic usage of the `<turbo-frame>` tag in Blade views, including generating a dynamic DOM ID using the `@domid()` directive.

```blade
<turbo-frame id="@domid($post, 'create_comment')">
    <p>Loading...</p>
</turbo-frame>
```

--------------------------------

### Use Custom Turbo Stream Action

Source: https://turbo-laravel.com/docs/overview

This HTML snippet shows how to use a custom Turbo Stream action named 'log'. It includes a 'message' attribute that will be processed by the corresponding JavaScript action.

```html
<turbo-stream action="log" message="Hello World"></turbo-stream>
```

--------------------------------

### Configure Turbo Refresh Method (Blade)

Source: https://turbo-laravel.com/docs/overview

Provides Blade components for configuring Turbo's refresh method to 'morph' and preserve scroll position, offering a more convenient way to manage these settings in Laravel.

```blade
<x-turbo::refreshes-with method="morph" scroll="preserve" />

```

--------------------------------

### Fake Turbo Stream Broadcasts for Testing

Source: https://turbo-laravel.com/docs/testing

Use `TurboStream::fake()` to capture and assert on Turbo Stream broadcasts sent from any mechanism in Turbo Laravel. This is useful for testing broadcasted content and channels.

```PHP
use App\Models\Todo;
use HotwiredLaravel\TurboLaravel\Facades\TurboStream;
use HotwiredLaravel\TurboLaravel\Broadcasting\PendingBroadcast;

class CreatesCommentsTest extends TestCase
{
    /** @test */
    public function content_is_required()
    {
        TurboStream::fake();

        $todo = Todo::factory()->create();

        $this->turbo()->post(route('todos.comments.store', $todo), [
            'content' => null,
        ])->assertInvalid(['content']);

        TurboStream::assertNothingWasBroadcasted();
    }

    /** @test */
    public function creates_comments()
    {
        TurboStream::fake();

        $todo = Todo::factory()->create();

        $this->turbo()->post(route('todos.comments.store', $todo), [
            'content' => 'Hey, this is really nice!',
        ])->assertTurboStream();

        TurboStream::assertBroadcasted(function (PendingBroadcast $broadcast) use ($todo) {
            return $broadcast->target === 'comments'
                && $broadcast->action === 'append'
                && $broadcast->partialView === 'comments.partials.comment'
                && $broadcast->partialData['comment']->is($todo->comments->first())
                && count($broadcast->channels) === 1
                && $broadcast->channels[0]->name === sprintf('private-%s', $todo->broadcastChannel());
        });
    }
}
```

--------------------------------

### Configure Turbo Refresh Method (HTML)

Source: https://turbo-laravel.com/docs/overview

Configures Turbo 8 to morph the page content instead of just replacing it, and preserves scroll position. This is done using meta tags in the HTML.

```html
<meta name="turbo-refresh-method" content="morph">
<meta name="turbo-refresh-scroll" content="preserve">

```

--------------------------------

### Simulate Hotwire Native Request

Source: https://turbo-laravel.com/docs/testing

This snippet demonstrates how to simulate a request from a Hotwire Native client using the `$this->hotwireNative()` method provided by the `InteractsWithTurbo` trait. It's useful for testing mobile app interactions.

```PHP
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateCommentsTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creating_comments_from_native_recedes()
    {
        $post = Post::factory()->create();

        $this->assertCount(0, $post->comments);

        $this->hotwireNative()->post(route('posts.comments.store', $post), [
            'content' => 'Hello World',
        ])->assertOk();

        $this->assertCount(1, $post->refresh()->comments);
        $this->assertEquals('Hello World', $post->comments->first()->content);
    }
}
```

--------------------------------

### Turbo Stream with View Instance Content (PHP)

Source: https://turbo-laravel.com/docs/turbo-streams

This snippet demonstrates passing a Laravel view instance as content to a Turbo Stream action. The `append()` method targets 'some_dom_id' and renders a 'greetings' view with a 'name' variable.

```PHP
turbo_stream()->append('some_dom_id', view('greetings', [
    'name' => 'Tester',
]));
```

--------------------------------

### Turbo Stream HTML Update with Morph

Source: https://turbo-laravel.com/docs/turbo-streams

Presents the HTML output for a Turbo Stream action using 'update' with the `method="morph"` attribute, signifying DOM morphing.

```HTML
<turbo-stream action="update" target="comments_post_123" method="morph">
    <template>...</template>
</turbo-stream>
```

--------------------------------

### Detect Request Accepts Turbo Streams

Source: https://turbo-laravel.com/docs/helpers

The `request()->wantsTurboStream()` macro checks if an incoming request includes the `Accept: text/vnd.turbo-stream.html` header, indicating it originated from a Turbo client.

```PHP
request()->wantsTurboStream();
```

--------------------------------

### Configure Scroll Behavior with <x-turbo::refresh-scroll>

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::refresh-scroll> component configures the scroll behavior during Turbo visits, offering 'reset' or 'preserve' options for better user experience.

```html
<x-turbo::refresh-scroll scroll="preserve" />
```

--------------------------------

### Triggering Turbo Frame from Outside

Source: https://turbo-laravel.com/docs/overview

Illustrates how to trigger updates for a specific Turbo Frame from elements outside of the frame itself using the 'data-turbo-frame' attribute.

```html
<div>
    <a href="/somewhere" data-turbo-frame="my_frame">I'm a link</a>

    <turbo-frame id="my_frame">
        ...
    </turbo-frame>
</div>

```

--------------------------------

### Define Custom Turbo Stream Action

Source: https://turbo-laravel.com/docs/overview

This JavaScript code demonstrates how to define a custom Turbo Stream action named 'log'. It logs a 'message' attribute to the console when triggered. This requires the Turbo JavaScript library.

```javascript
import { StreamActions } from "@hotwired/turbo"

StreamActions.log = function () {
  console.log(this.getAttribute("message"))
}
```

--------------------------------

### Turbo Stream Helper Function

Source: https://turbo-laravel.com/docs/helpers

The `turbo_stream()` helper function provides a convenient way to generate Turbo Streams, similar to the `Response::turboStream()` macro. It can be used for actions like appending elements.

```PHP
use function HotwiredLaravel\TurboLaravel\turbo_stream;

turbo_stream()->append($comment);
```

--------------------------------

### Broadcasting with Eloquent Model Channel

Source: https://turbo-laravel.com/docs/broadcasting

Demonstrates broadcasting a Turbo Stream to a channel derived from an Eloquent model, such as a post or user. The `broadcastTo()` method automatically handles channel resolution.

```php
turbo_stream($comment)
    ->broadcastTo($comment->post, fn ($broadcast) => $broadcast->toOthers());
```

--------------------------------

### Turbo Stream Replace with Morph

Source: https://turbo-laravel.com/docs/turbo-streams

Illustrates generating a Turbo Stream with the 'replace' action and the `method="morph"` attribute using the `morph()` method. This enables DOM morphing for the update.

```PHP
turbo_stream()->replace(dom_id($post, 'comments'), view('comments.partials.comment', [
    'comment' => $comment,
]))->morph();
```

--------------------------------

### Exempt Page from Cache with <x-turbo::exempts-page-from-cache>

Source: https://turbo-laravel.com/docs/helpers

The <x-turbo::exempts-page-from-cache> component adds a meta tag to prevent Turbo from caching the current page, ensuring fresh content on visits.

```html
<x-turbo::exempts-page-from-cache />
```

--------------------------------

### Turbo Stream Response Controller Logic

Source: https://turbo-laravel.com/docs/testing

This PHP controller code shows how to conditionally return a Turbo Stream response using `turbo_stream($todo)` if the request `wantsTurboStream()`, otherwise it performs a standard redirect.

```PHP
class TodosController
{
    public function store()
    {
        $todo = auth()->user()->todos()->create(request()->validate([
            'content' => ['required'],
        ]));

        if (request()->wantsTurboStream()) {
            return turbo_stream($todo);
        }

        return redirect()->route('todos.index');
    }
}
```

--------------------------------

### Broadcast Custom Action with TurboStream Facade

Source: https://turbo-laravel.com/docs/broadcasting

Allows broadcasting of any custom Turbo Stream action using `broadcastAction()`. This provides flexibility beyond the predefined broadcast methods.

```php
TurboStream::broadcastAction('scroll_to', target: 'todo_123');
```

--------------------------------

### Turbo Stream View Helper Function

Source: https://turbo-laravel.com/docs/helpers

The `turbo_stream_view()` function allows creating Turbo Streams within separate Blade views, enabling the use of Blade's template extensions and features for complex stream compositions.

```PHP
use function HotwiredLaravel\TurboLaravel\turbo_stream_view;

return turbo_stream_view('comments.turbo.created', [
    'comment' => $comment,
]);
```

--------------------------------

### DOM Class Helper Function

Source: https://turbo-laravel.com/docs/helpers

The `dom_class()` helper function generates DOM classes based on model names. It can also accept a context prefix to create prefixed class names, like `reactions_list_comment`.

```PHP
use function HotwiredLaravel\TurboLaravel\dom_class;

dom_class($comment);
```

```PHP
dom_class($comment, 'reactions_list');
```

--------------------------------

### Listen to Turbo Streams Broadcasts with turbo-echo-stream-source

Source: https://turbo-laravel.com/docs/broadcasting

This snippet demonstrates how to use the `<turbo-echo-stream-source>` custom HTML tag to listen for Turbo Stream broadcasts on a specific channel. It requires the channel name to be explicitly provided.

```html
<turbo-echo-stream-source
    channel="App.Models.Post.{{ $post->id }}"
/>
```

--------------------------------

### Listen to Turbo Streams Broadcasts with x-turbo::stream-from Component

Source: https://turbo-laravel.com/docs/broadcasting

This snippet shows how to use the `<x-turbo::stream-from>` Blade component for listening to Turbo Stream broadcasts. It automatically determines the channel name from the provided model source. It also illustrates how to specify the broadcast type (e.g., 'public').

```blade
<x-turbo::stream-from :source="$post" />
```

```blade
<x-turbo::stream-from :source="$post" type="public" />
```

--------------------------------

### DOM ID Helper Function

Source: https://turbo-laravel.com/docs/helpers

The `dom_id()` helper function generates DOM IDs for models. It prefixes new model instances with `create_` and strips the model's FQCN. It can be used directly in Blade views.

```PHP
use function HotwiredLaravel\TurboLaravel\dom_id;

dom_id($comment);
```

--------------------------------

### Combine Multiple Turbo Streams in Laravel

Source: https://turbo-laravel.com/docs/turbo-streams

This snippet demonstrates how to return multiple Turbo Streams within a single response using the `turbo_stream` helper function. It shows appending a comment and updating a comment count.

```PHP
return turbo_stream([
    turbo_stream()
        ->append($comment)
        ->target(dom_id($comment->post, 'comments')),
    turbo_stream()
        ->update(dom_id($comment->post, 'comments_count'), view('posts.partials.comments_count', [
            'post' => $comment->post,
        ])),
]);
```

--------------------------------

### Use InteractsWithHotwireNativeNavigation Trait in Controller

Source: https://turbo-laravel.com/docs/hotwire-native

Demonstrates how to use the `InteractsWithHotwireNativeNavigation` trait in a Laravel controller to conditionally redirect based on whether the request originates from a Hotwire Native client. It falls back to a regular redirect for web clients.

```PHP
use HotwiredLaravel\TurboLaravel\Http\Controllers\Concerns\InteractsWithHotwireNativeNavigation;

class TraysController extends Controller
{
    use InteractsWithHotwireNativeNavigation;

    public function store()
    {
        // Tray creation...

        return $this->recedeOrRedirectTo(route('trays.show', $tray));
    }
}
```

--------------------------------

### Using x-turbo::stream Blade Component

Source: https://turbo-laravel.com/docs/turbo-streams

Shows how to use the `<x-turbo::stream>` Blade component for a cleaner syntax when generating Turbo Streams. It automatically handles DOM ID resolution when a model or array is passed to the target attribute.

```Blade
@include('layouts.turbo.flash_stream')

<x-turbo::stream :target="[$comment->post, 'comments']" action="append">
    @include('comments.partials.comment', ['comment' => $comment])
</x-turbo::stream>
```

--------------------------------

### Conditional Rendering for Hotwire Native (Blade)

Source: https://turbo-laravel.com/docs/hotwire-native

Conditionally renders content for Hotwire Native clients using the `@hotwirenative` Blade directive. This is useful for including mobile-specific assets like stylesheets.

```Blade
@hotwirenative
    <link rel="stylesheet" href="mobile.css">
@endhotwirenative

```

--------------------------------

### Turbo Stream Partial for Flash Messages

Source: https://turbo-laravel.com/docs/turbo-streams

This Blade partial demonstrates how to conditionally append flash messages to a 'notice' target if a 'status' session variable exists. It's designed to be included in other Turbo Stream views.

```Blade
@if (session()->has('status'))
<turbo-stream target="notice" action="append">
    <template>
        @include('layouts.partials.flash')
    </template>
</turbo-stream>
@endif
```

--------------------------------

### Broadcasting to Private Channel with turbo_stream()

Source: https://turbo-laravel.com/docs/broadcasting

Illustrates broadcasting to a private channel using the `broadcastToPrivateChannel()` method with the `turbo_stream()` response builder. This is useful for targeted user communication.

```php
turbo_stream()
    ->append('notifications', 'Hello World')
    ->broadcastToPrivateChannel('user.123', fn ($broadcast) => $broadcast->toOthers())
```

--------------------------------

### Conditional Rendering for Non-Hotwire Native (Blade)

Source: https://turbo-laravel.com/docs/hotwire-native

Conditionally renders content for clients that are NOT Hotwire Native using the `@unlesshotwirenative` Blade directive. This allows for displaying content exclusively to web browser clients.

```Blade
@unlesshotwirenative
    <h1>Hello, Non-Hotwire Native Users!</h1>
@endunlesshotwirenative

```

--------------------------------

### Complex Custom Turbo Stream View with Blade

Source: https://turbo-laravel.com/docs/turbo-streams

Illustrates a more complex custom Turbo Stream view using Blade, including including a partial for flash messages and appending a new comment. It utilizes Blade's templating capabilities for dynamic content.

```Blade
@include('layouts.turbo.flash_stream')

<turbo-stream target="@domid($comment->post, 'comments')" action="append">
    <template>
        @include('comments.partials.comment', ['comment' => $comment])
    </template>
</turbo-stream>
```

--------------------------------

### Assert Turbo Stream Responses

Source: https://turbo-laravel.com/docs/testing

This snippet demonstrates testing for Turbo Stream responses using `assertTurboStream()` and asserting non-Turbo Stream responses with `assertNotTurboStream()`. These macros are part of the `InteractsWithTurbo` trait.

```PHP
use HotwiredLaravel\TurboLaravel\Testing\InteractsWithTurbo;

class CreateTodosTest extends TestCase
{
    use InteractsWithTurbo;

    /** @test */
    public function creating_todo_from_turbo_request_returns_turbo_stream_response()
    {
        $this->turbo()->post(route('todos.store'), [
            'content' => 'Test the app',
        ])->assertTurboStream();
    }

    /** @test */
    public function creating_todo_from_regular_request_does_not_return_turbo_stream_response()
    {
        // Notice we're not chaining the `$this->turbo()` method here.
        $this->post(route('todos.store'), [
            'content' => 'Test the app',
        ])->assertNotTurboStream();
    }
}
```

--------------------------------

### Page Reload Blade Component

Source: https://turbo-laravel.com/docs/helpers

Use the `x-turbo::page-requires-reload` Blade component to force a full page reload, breaking out of Turbo Frame navigations. This is useful for scenarios like login screens.

```HTML
<x-turbo::page-requires-reload />
```

```HTML
<meta name="turbo-visit-control" content="reload">
```

--------------------------------

### Configure Redirect Guessing Exceptions in Turbo Laravel

Source: https://turbo-laravel.com/docs/conventions

This configuration allows you to specify routes for which Turbo Laravel should not attempt to guess the associated form rendering routes. This is useful for defining exceptions to the default redirection behavior, particularly after failed validations.

```PHP
return [
    // ...
    'redirect_guessing_exceptions' => [
        '/some-page',
    ],
];
```
Tokens:
Raw