> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Support Contracts (Arrayable / Jsonable / Htmlable / Responsable)

> De vier belangrijkste contracts van Illuminate\Contracts\Support, uitgelegd op basis van de officiële broncode van Laravel 13.

## Wat zijn Support Contracts?

In `Illuminate\Contracts\Support` zijn kleine maar belangrijke interfaces verzameld die in heel Laravel worden gebruikt.\
Vooral `Arrayable` / `Jsonable` / `Htmlable` / `Responsable` zijn de basispatronen om value objects, DTO's en responseobjecten op een natuurlijke manier in de bestaande flows van Laravel mee te laten draaien.

```mermaid theme={null}
flowchart TD
    A["Value Object / DTO"] --> B["Arrayable<br>toArray()"]
    A --> C["Jsonable<br>toJson($options = 0)"]
    A --> D["Htmlable<br>toHtml()"]
    A --> E["Responsable<br>toResponse($request)"]
    B --> F["JsonResponse / Eloquent / Collection"]
    C --> F
    D --> G["e() helper / Blade output"]
    E --> H["Controller return / Router::toResponse()"]
```

<Info>
  De signatures die we hier behandelen verwijzen naar de officiële broncode van Laravel 13.x (`laravel/framework`).
</Info>

## 1) Arrayable

### Interface-definitie

```php theme={null}
interface Arrayable
{
    public function toArray();
}
```

### Implementatievoorbeeld

```php theme={null}
use Illuminate\Contracts\Support\Arrayable;

final class Money implements Arrayable
{
    public function __construct(
        public readonly int $amount,
        public readonly string $currency,
    ) {}

    public function toArray(): array
    {
        return [
            'amount' => $this->amount,
            'currency' => $this->currency,
        ];
    }
}
```

### Gebruiksvoorbeelden in de Laravel-core

* `Illuminate\Database\Eloquent\Model` implementeert `Arrayable` en biedt `toArray()`
* Als `Illuminate\Http\JsonResponse::setData()` een `Arrayable` detecteert, serialiseert die via `json_encode($data->toArray(), ...)`

### Toepassing in packageontwikkeling

* Je kunt DTO's en value objects in een gemeenschappelijk formaat gieten voor controllers, resources en logoutput
* Je kunt de verantwoordelijkheid voor conversie naar een `array` binnen het object zelf houden

## 2) Jsonable

### Interface-definitie

```php theme={null}
interface Jsonable
{
    public function toJson($options = 0);
}
```

### Implementatievoorbeeld

```php theme={null}
use Illuminate\Contracts\Support\Jsonable;

final class ApiPayload implements Jsonable
{
    public function __construct(
        private array $data,
    ) {}

    public function toJson($options = 0): string
    {
        return json_encode([
            'data' => $this->data,
            'generated_at' => now()->toIso8601String(),
        ], $options | JSON_THROW_ON_ERROR);
    }
}
```

### Gebruiksvoorbeelden in de Laravel-core

* `Model` implementeert ook `Jsonable` en biedt `toJson($options = 0)`
* `JsonResponse::setData()` controleert eerst op `Jsonable` en gebruikt dan `toJson()`

### Toepassing in packageontwikkeling

* Je kunt de JSON-structuur strikt vastleggen voor bijvoorbeeld auditlogs en webhook-verzendingen
* Je legt de JSON-representatie vanuit je domein expliciet vast, in plaats van die aan `json_encode()` over te laten

## 3) Htmlable

### Interface-definitie

```php theme={null}
interface Htmlable
{
    public function toHtml();
}
```

### Implementatievoorbeeld

```php theme={null}
use Illuminate\Contracts\Support\Htmlable;

final class BadgeHtml implements Htmlable
{
    public function __construct(
        private string $label,
    ) {}

    public function toHtml(): string
    {
        $escaped = e($this->label);

        return "<span class=\"badge\">{$escaped}</span>";
    }
}
```

### Gebruiksvoorbeelden in de Laravel-core

* `Illuminate\Support\HtmlString` implementeert `Htmlable`
* De `e()`-helper geeft `toHtml()` terug als het argument een `Htmlable` is (zonder opnieuw te escapen)

### Toepassing in packageontwikkeling

* Je maakt de verantwoordelijkheidsgrens duidelijk voor het veilig doorgeven van HTML-fragmenten binnen Blade
* Ook waar je `{!! $obj !!}` gebruikt, blijft de output makkelijk als object te beheren

<Tip>
  Concateneer binnen klassen die `Htmlable` implementeren gebruikersinvoer niet zomaar, maar escape de benodigde waarden eerst met `e()` voordat je ze insluit.
</Tip>

## 4) Responsable

### Interface-definitie

```php theme={null}
interface Responsable
{
    public function toResponse($request);
}
```

### Implementatievoorbeeld

```php theme={null}
use Illuminate\Contracts\Support\Responsable;

final class ExportCsvResponse implements Responsable
{
    public function __construct(
        private array $rows,
        private string $filename = 'export.csv',
    ) {}

    /**
     * @param \Illuminate\Http\Request $request
     */
    public function toResponse($request)
    {
        return response()->streamDownload(function () {
            $stream = fopen('php://output', 'w');

            foreach ($this->rows as $row) {
                fputcsv($stream, $row);
            }

            fclose($stream);
        }, $this->filename, [
            'Content-Type' => 'text/csv',
        ]);
    }
}
```

### Gebruiksvoorbeelden in de Laravel-core

* `Illuminate\Routing\Router::toResponse()` controleert eerst op `Responsable` en roept `$response->toResponse($request)` aan
* `Illuminate\Http\Resources\Json\JsonResource` implementeert `Responsable`, waardoor je vanuit een controller direct `return UserResource::make($user);` kunt doen

### Toepassing in packageontwikkeling

* Je kunt het genereren van de response delegeren aan een object, zonder in de controller arrays samen te stellen
* Het maakt het ontwerp "een DTO direct returnen" makkelijk en scheidt de HTTP-representatie van de domeinrepresentatie

## Gids voor het kiezen van een implementatie

<Steps>
  <Step title="Je wilt data als array hergebruiken">
    Implementeer `Arrayable` en centraliseer de normalisatielogica in `toArray()`.
  </Step>

  <Step title="Je wilt de JSON-representatie beheersen">
    Implementeer `Jsonable` en maak het uitvoerformaat expliciet in `toJson($options)`.
  </Step>

  <Step title="Je wilt iets als HTML-fragment behandelen">
    Implementeer `Htmlable` en geef de gerenderde string terug in `toHtml()`.
  </Step>

  <Step title="Je wilt direct een HTTP-response teruggeven">
    Implementeer `Responsable` en centraliseer de verantwoordelijkheid in `toResponse($request)`.
  </Step>
</Steps>

## Verder lezen

<Columns cols={2}>
  <Card title="Macroable-trait" icon="puzzle-piece" href="/nl/advanced/macroable">
    Leer het uitbreidingspatroon waarmee je eigen methodes toevoegt aan bestaande klassen.
  </Card>

  <Card title="Conditionable-trait" icon="git-branch" href="/nl/advanced/conditionable">
    Leer het ontwerp waarin je met `when()` / `unless()` conditionele logica inbouwt.
  </Card>

  <Card title="tap() helper / Tappable" icon="hand-point-up" href="/nl/advanced/tap">
    Leer het ketenontwerp dat een waarde teruggeeft terwijl je bijeffecten tussenvoegt.
  </Card>

  <Card title="Dumpable-trait" icon="bug" href="/nl/advanced/dumpable">
    Leer de debugtechniek waarmee je `dump()` / `dd()` in objecten inbouwt.
  </Card>
</Columns>


## Related topics

- [Contracts](/nl/contracts.md)
- [Laravel Boost](/nl/boost.md)
- [Een custom agent voor Boost maken](/nl/advanced/boost-custom-agent.md)
- [Uitgestelde service providers](/nl/advanced/deferred-provider.md)
- [Helperfuncties](/nl/helpers.md)