Laravel Options

https://github.com/spatie/laravel-options
Admin
This package simplifies the creation of lists of options for select fields in web applications by...
Tokens:8,099
Snippets:64
Trust Score:10
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Iterating Over Options for HTML Select

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Provides an example of iterating over a set of options to generate HTML `<option>` tags. This is useful for populating dropdown lists in forms. The loop accesses the 'value' and 'label' of each option.

```php
foreach(Options::forEnum(Hobbit::class) as $option){
    echo "<option value=\"{$option['value']}\">{$option['label']}</option>";
}
```

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

### Install Spatie Laravel Options via Composer

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Installs the spatie/laravel-options package into a Laravel project using Composer. This is the primary method for adding the package to your application.

```bash
composer require spatie/laravel-options
```

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

### Appending Data to Enum Options in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Illustrates how to append additional data to each option generated from an enum. This is useful for adding contextual information, such as a 'ring_bearer' flag in the example.

```php
Options::forEnum(Hobbit::class)->append(fn(Hobbit $hobbit) => [
    'ring_bearer' => $hobbit === Hobbit::Frodo || $hobbit === Hobbit::Sam
]);
```

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

### Laravel Validation Rule for Options Enum

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Demonstrates how to generate a Laravel validation rule from an enum using spatie/laravel-options. The `toValidationRule()` method converts the options into an appropriate validation rule string. This example assumes a `Hobbit` enum.

```php
$request->validate([
    // ['in:frodo,sam,merry,pippin']
    'hobbit' => Options::forEnum(Hobbit::class)->toValidationRule()
]);
```

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

### Publish Options Configuration File

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Publishes the configuration file for the spatie/laravel-options package. This allows customization of option label and value keys.

```bash
php artisan vendor:publish --tag="options-config"
```

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

### Return Options as JSON Response in Controller

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Demonstrates how to return options generated from an enum as part of a JSON response from a Laravel controller. The package automatically handles the JSON conversion.

```php
class ShowHobbitsController{
    public function __invoke(RingBearer $ringBearer){
        return [
            'ring_bearer' => $ringBearer,
            'hobbit_options' => Options::forEnum(Hobbit::class)
        ]   
    }
}
```

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

### JSON Conversion and Iteration with PHP Enums

Source: https://context7.com/spatie/laravel-options/llms.txt

Demonstrates how to automatically convert enums to JSON for API responses and iterate over them to generate HTML select options. It also shows explicit JSON conversion and array access.

```php
use Spatie\LaravelOptions\Options;

enum Hobbit: string {
    case Frodo = 'frodo';
    case Sam = 'sam';
}

// Automatic JSON conversion in controllers
class ShowHobbitsController
{
    public function __invoke()
    {
        return [
            'hobbits' => Options::forEnum(Hobbit::class),
            'message' => 'Fellowship assembled'
        ];
        // JSON: {"hobbits": [{"label": "Frodo", "value": "frodo"}, ...], "message": "..."}
    }
}

// Explicit JSON conversion
$json = Options::forEnum(Hobbit::class)->toJson();
// '[{"label":"Frodo","value":"frodo"},{"label":"Sam","value":"sam"}]'

// Iteration support
$options = Options::forEnum(Hobbit::class);
foreach ($options as $option) {
    echo "<option value=\"{$option['value']}\">{$option['label']}</option>";
}
// <option value="frodo">Frodo</option>
// <option value="sam">Sam</option>

// Array access
$array = $options->toArray();
$firstOption = $array[0];
// ['label' => 'Frodo', 'value' => 'frodo']
```

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

### Create Empty Options List - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Creates an empty options list, useful for scenarios where no options are available or needed initially.

```php
Options::empty();
```

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

### Customizing Enum Label Resolution in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Illustrates how to specify a custom method name or use a closure to resolve labels for enum options when the default `labels` method is not used or a different logic is required.

```php
Options::forEnum(Hobbit::class, 'hobbitLabels');
```

```php
Options::forEnum(Hobbit::class, fn(Hobbit $hobbit) => $hobbit->name. ' from the shire');
```

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

### Customizing Option Keys with PHP Configuration

Source: https://context7.com/spatie/laravel-options/llms.txt

Shows how to globally customize the 'label' and 'value' keys used in option arrays by modifying the `config/options.php` file. This allows for flexible mapping of data source attributes to option properties.

```php
// config/options.php
return [
    'label_key' => 'name',
    'value_key' => 'id',
];

// All options now use custom keys
$options = Options::forEnum(Hobbit::class)->toArray();
// [
//     ['name' => 'Frodo', 'id' => 'frodo'],
//     ['name' => 'Sam', 'id' => 'sam'],
//     ['name' => 'Merry', 'id' => 'merry'],
//     ['name' => 'Pippin', 'id' => 'pippin'],
// ]

// Publish config file
// php artisan vendor:publish --tag="options-config"
```

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

### Implement Selectable Interface for Model Options - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Allows models to define their option representation by implementing the `Selectable` interface and the `toSelectOption` method. This simplifies option generation by automatically using the returned `SelectOption`'s label and value.

```php
class Wizard extends Model implements SelectableContractsSelectableContractsSelectableContractsSelectableContracts\Selectable
{
    public function toSelectOption(): SelectOption
    {
        return new SelectOption(
            $this->getName(),
            $this->getUuid()
        );
    }
}

Options::forModels(Wizard::class);

// With extra data
public function toSelectOption(): SelectOption
{
    return new SelectOption(
        $this->getName(),
        $this->getUuid(),
        ['color' => $this->color]
    );
}
```

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

### Sorting Enum Options in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Demonstrates how to sort options generated from enums. It shows both default sorting by label and custom sorting using a closure.

```php
Options::forEnum(Hobbit::class)->sort();
```

```php
Options::forEnum(Hobbit::class)->sort(fn(Hobbit $hobbit) => $hobbit->value);
```

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

### Create Options from Spatie Model States using PHP

Source: https://context7.com/spatie/laravel-options/llms.txt

Generates select options from Spatie model states, automatically resolving labels. It supports using a specific model instance and custom label resolution via a closure. Filtering is available using `only()` and `except()`.

```php
use Spatie\LaravelOptions\Options;
use App\States\RingState;
use App\States\LostRingState;
use App\States\DestroyedRingState;

// Assuming RingState, LostRingState, DestroyedRingState are defined and extend a base state class

// Basic usage
$options = Options::forStates(RingState::class)->toArray();

// With specific model instance (assuming Ring model exists)
// $ring = Ring::find(1);
// $options = Options::forStates(RingState::class, $ring)->toArray();

// Custom label resolution
$options = Options::forStates(
    RingState::class,
    label: fn(RingState $state) => strtoupper($state->label())
)->toArray();

// Filter states with only() and except()
$options = Options::forStates(RingState::class)
    ->only(LostRingState::class, DestroyedRingState::class)
    ->toArray();

$options = Options::forStates(RingState::class)
    ->except(DestroyedRingState::class)
    ->toArray();
```

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

### Implement Selectable Interface for Custom Options using PHP

Source: https://context7.com/spatie/laravel-options/llms.txt

Allows models and other classes to define custom option transformations by implementing the `Selectable` interface. The `toSelectOption()` method should return a `SelectOption` object, enabling automatic option generation with `forModels()` and `forSelectableOptions()`.

```php
use Spatie\LaravelOptions\Selectable;
use Spatie\LaravelOptions\SelectOption;
use Spatie\LaravelOptions\Options;
use Illuminate\Database\Eloquent\Model;

class Wizard extends Model implements Selectable
{
    public function toSelectOption(): SelectOption
    {
        return new SelectOption(
            label: $this->getName(),
            value: $this->getUuid(),
            extra: ['color' => $this->color, 'power_level' => $this->power]
        );
    }
}

// Now forModels() uses the Selectable implementation automatically
// $options = Options::forModels(Wizard::class)->toArray();
// [
//     ['label' => 'Gandalf', 'value' => '...uuid...', 'color' => 'gray', 'power_level' => 9001],
//     ['label' => 'Saruman', 'value' => '...uuid...', 'color' => 'white', 'power_level' => 8500],
// ]

// Works with non-model classes too
class SelectableOption implements Selectable
{
    public function toSelectOption(): SelectOption
    {
        return new SelectOption($this->label, $this->id);
    }
}

// $options = Options::forSelectableOptions([
//     SelectableOption::find(1),
//     SelectableOption::find(2),
// ])->toArray();
```

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

### Including Specific Enum Options with 'only' in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Explains how to use the `only` method to select and include only specific enum options. This is useful when you need a predefined subset of options.

```php
Options::forEnum(Hobbit::class)->only(Hobbit::Frodo, Hobbit::Sam);
```

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

### Default Spatie Laravel Options Configuration

Source: https://github.com/spatie/laravel-options/blob/main/README.md

The default configuration file for the spatie/laravel-options package. It defines the keys used for 'label' and 'value' in the generated option structures.

```php
return [
    /*
     * The key used in an option to describe the label of the option
     */
    'label_key' => 'label',

    /*
     * The key used in an option to describe the value of the option
     */
    'value_key' => 'value',
];
```

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

### Rejecting Enum Options in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Demonstrates how to reject specific options from being included in the generated options array. This is the inverse of filtering and is achieved using a closure.

```php
Options::forEnum(Hobbit::class)->reject(fn(Hobbit $hobbit) => $hobbit === Hobbit::Frodo);
```

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

### Create Options from Selectable Objects - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Generates options from any PHP class that implements the `Selectable` interface. This provides a flexible way to create options from non-model objects.

```php
Options::forSelectableOptions([
    SelectableOption::find(1),
    SelectableOption::find(2),
    SelectableOption::find(3),
]);
```

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

### Create Options from Array using PHP

Source: https://context7.com/spatie/laravel-options/llms.txt

Generates select options from associative or indexed arrays. Supports filtering with `only()` and `except()`, and can use array values as labels when `useLabelsAsValue` is true.

```php
use Spatie\LaravelOptions\Options;

// Associative array
$kingdoms = [
    'gondor' => 'Gondor',
    'rohan' => 'Rohan',
    'mordor' => 'Mordor',
];

$options = Options::forArray($kingdoms)->toArray();
// [
//     ['label' => 'Gondor', 'value' => 'gondor'],
//     ['label' => 'Rohan', 'value' => 'rohan'],
//     ['label' => 'Mordor', 'value' => 'mordor'],
// ]

// Plain array with labels as values
$options = Options::forArray(
    ['Gondor', 'Rohan', 'Mordor'],
    useLabelsAsValue: true
)->toArray();
// [
//     ['label' => 'Gondor', 'value' => 'Gondor'],
//     ['label' => 'Rohan', 'value' => 'Rohan'],
//     ['label' => 'Mordor', 'value' => 'Mordor'],
// ]

// Filter with only() and except() using keys
$options = Options::forArray($kingdoms)->only('gondor', 'rohan')->toArray();
// [['label' => 'Gondor', 'value' => 'gondor'], ['label' => 'Rohan', 'value' => 'rohan']]

$options = Options::forArray($kingdoms)->except('mordor')->toArray();
// [['label' => 'Gondor', 'value' => 'gondor'], ['label' => 'Rohan', 'value' => 'rohan']]
```

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

### Create Options from Eloquent Models with Spatie Laravel Options

Source: https://context7.com/spatie/laravel-options/llms.txt

Generates option arrays from Eloquent models, model collections, query builders, or single model instances. Allows custom label and value resolution using closures, and filtering with `only()` and `except()` methods.

```php
use Spatie\LaravelOptions\Options;
use App\Models\Wizard;

// From model class - fetches all records
$options = Options::forModels(Wizard::class)->toArray();
// [
//     ['label' => 'Gandalf', 'value' => 1],
//     ['label' => 'Saruman', 'value' => 2],
// ]

// From query builder with conditions
$options = Options::forModels(
    Wizard::query()->where('color', 'gray'),
    label: 'full_name',
    value: 'uuid'
)->toArray();

// From collection
$wizards = Wizard::all();
$options = Options::forModels($wizards)->toArray();

// From single model
$gandalf = Wizard::first();
$options = Options::forModels($gandalf)->toArray();

// Custom label and value with closures
$options = Options::forModels(
    Wizard::class,
    label: fn(Wizard $wizard) => $wizard->getName() . ' the ' . $wizard->color,
    value: fn(Wizard $wizard) => $wizard->uuid
)->toArray();
// [
//     ['label' => 'Gandalf the Gray', 'value' => '...uuid...'],
//     ['label' => 'Saruman the White', 'value' => '...uuid...'],
// ]

// Filter models with only() and except()
$options = Options::forModels(Wizard::class)->only(Wizard::where('name', 'gandalf')->first())->toArray();
$options = Options::forModels(Wizard::class)->except(Wizard::where('name', 'saruman')->first())->toArray();

```

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

### Create Array Options - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Generates options from an associative array where keys are values and values are labels. It also supports plain arrays, using labels as values when `useLabelsAsValue` is set to true. Filtering with `only` and `except` is supported using array keys.

```php
Options::forArray([
    'gondor' => 'Gondor',
    'rohan' => 'Rohan',
    'mordor' => 'Mordor',
]);

Options::forArray([
    'Gondor',
    'Rohan',
    'Mordor',
], useLabelsAsValue: true);

Options::forArray($options)->only('gondor', 'rohan');
Options::forArray($options)->except('gondor', 'rohan');
```

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

### Generate Laravel Validation Rules from Options

Source: https://context7.com/spatie/laravel-options/llms.txt

Automatically converts generated select options into Laravel validation rules, simplifying form request validation. This method can be chained with `nullable()` for optional fields. Dependencies include the Spatie Laravel Options package and Laravel's validation system.

```php
use Spatie\LaravelOptions\Options;
use Illuminate\Http\Request;

enum Hobbit: string {
    case Frodo = 'frodo';
    case Sam = 'sam';
    case Merry = 'merry';
    case Pippin = 'pippin';
}

// Basic validation rule
$request->validate([
    'hobbit' => Options::forEnum(Hobbit::class)->toValidationRule()
    // Generates: ['in:frodo,sam,merry,pippin']
]);

// Nullable validation rule
$request->validate([
    'hobbit' => Options::forEnum(Hobbit::class)->nullable()->toValidationRule()
    // Generates: ['nullable', 'in:frodo,sam,merry,pippin']
]);

// Complete validation example
class RingBearerController
{
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => ['required', 'string', 'max:255'],
            'hobbit' => Options::forEnum(Hobbit::class)->toValidationRule(),
            'kingdom' => Options::forArray([
                'shire' => 'The Shire',
                'gondor' => 'Gondor',
                'rohan' => 'Rohan'
            ])->nullable()->toValidationRule(),
        ]);

        // Process validated data
        return response()->json(['success' => true, 'data' => $validated]);
    }
}

```

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

### Create Model Options - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Generates options from Eloquent models. By default, it uses the model's `id` as the value and `name` as the label. Custom value and label fields or closures can be specified. Supports filtering with `only` and `except`.

```php
Options::forModels(Wizard::class);
Options::forModels(Wizard::first());
Options::forModels(Wizard::all());
Options::forModels(Wizard::query()->where('name', 'gandalf'));
Options::forModels(Wizard::class, value: 'uuid');
Options::forModels(Wizard::class, value: fn(Wizard $wizard) => $wizard->uuid());
Options::forModels(Wizard::class, label: 'full_name');
Options::forModels(Wizard::class, label: fn(Wizard $wizard) => $wizard->getName());
Options::forModels(Wizard::class)->only(Wizard::where('name', 'gandalf')->first());
Options::forModels(Wizard::class)->except(Wizard::where('name', 'gandalf')->first());
```

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

### Manipulate Options from Enums and Models

Source: https://context7.com/spatie/laravel-options/llms.txt

Provides methods to filter, sort, append data, and add null options when generating select options from PHP enums or Eloquent models. Dependencies include the Spatie Laravel Options package. Input can be enums or models, and output is an array of option objects.

```php
use Spatie\LaravelOptions\Options;

enum Hobbit: string {
    case Frodo = 'frodo';
    case Sam = 'sam';
    case Merry = 'merry';
    case Pippin = 'pippin';
}

// Filter with closure
$options = Options::forEnum(Hobbit::class)
    ->filter(fn(Hobbit $hobbit) => $hobbit === Hobbit::Frodo)
    ->toArray();
// [['label' => 'Frodo', 'value' => 'frodo']]

// Reject with closure
$options = Options::forEnum(Hobbit::class)
    ->reject(fn(Hobbit $hobbit) => $hobbit === Hobbit::Frodo)
    ->toArray();
// [['label' => 'Sam', 'value' => 'sam'], ['label' => 'Merry', 'value' => 'merry'], ['label' => 'Pippin', 'value' => 'pippin']]

// Sort alphabetically
$options = Options::forEnum(Hobbit::class)->sort()->toArray();
// [['label' => 'Frodo', ...], ['label' => 'Merry', ...], ['label' => 'Pippin', ...], ['label' => 'Sam', ...]]

// Sort with closure
$options = Options::forEnum(Hobbit::class)
    ->sort(fn(Hobbit $hobbit) => $hobbit->value)
    ->toArray();

// Append static data
$options = Options::forEnum(Hobbit::class)
    ->append(['movie' => 'Lord Of The Rings'])
    ->toArray();
// [
//     ['label' => 'Frodo', 'value' => 'frodo', 'movie' => 'Lord Of The Rings'],
//     ['label' => 'Sam', 'value' => 'sam', 'movie' => 'Lord Of The Rings'],
//     ...
// ]

// Append dynamic data with closure
$options = Options::forEnum(Hobbit::class)
    ->append(fn(Hobbit $hobbit) => [
        'ring_bearer' => $hobbit === Hobbit::Frodo || $hobbit === Hobbit::Sam,
        'upper' => strtoupper($hobbit->name)
    ])
    ->toArray();
// [
//     ['label' => 'Frodo', 'value' => 'frodo', 'ring_bearer' => true, 'upper' => 'FRODO'],
//     ['label' => 'Sam', 'value' => 'sam', 'ring_bearer' => true, 'upper' => 'SAM'],
//     ...
// ]

// Add nullable option
$options = Options::forEnum(Hobbit::class)->nullable()->toArray();
// [
//     ['label' => '-', 'value' => null],
//     ['label' => 'Frodo', 'value' => 'frodo'],
//     ...
// ]

// Custom nullable label and value
$options = Options::forEnum(Hobbit::class)
    ->nullable(label: 'Select a Hobbit', value: '')
    ->toArray();
// [['label' => 'Select a Hobbit', 'value' => ''], ['label' => 'Frodo', ...], ...]

// Make unique (removes duplicates by value)
use App\Models\Character;
$model = Character::first();
$options = Options::forModels([$model, $model])->unique()->toArray();
// [['label' => 'Aragon', 'value' => 1]]

// Push additional options manually
use Spatie\LaravelOptions\SelectOption;
$options = Options::forEnum(Hobbit::class)
    ->push(new SelectOption('Gandalf', 'gandalf'))
    ->toArray();
// [...hobbits..., ['label' => 'Gandalf', 'value' => 'gandalf']]

```

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

### Adding a Nullable Option to Enum Options in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Shows how to add a unique `null` option to the generated enum options. This includes customizing the label and value of the null option.

```php
Options::forEnum(Hobbit::class)->nullable();
```

```php
Options::forEnum(Hobbit::class)->nullable('Gandalf');
```

```php
Options::forEnum(Hobbit::class)->nullable(label: 'Gandalf', value: 'You Shall Not Pass');
```

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

### Create State Options - Spatie Laravel Options

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Generates options from Spatie model states. It automatically uses the `label` public method or property for the option label. Custom label methods/properties or closures can be specified. Supports filtering with `only` and `except`.

```php
Options::forStates(RingState::class);
Options::forStates(RingState::class, $ring);
Options::forStates(RingState::class, label: 'ringLabel');
Options::forStates(RingState::class, label: fn(RingState $state) => $state->label());
Options::forStates(RingState::class)->only(LostRingState::class, DestroyedRingState::class);
Options::forStates(RingState::class)->except(LostRingState::class, DestroyedRingState::class);
```

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

### Filtering Enum Options in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Shows how to filter the options generated from an enum, including only specific options using a closure. This reduces the number of options in the final array.

```php
Options::forEnum(Hobbit::class)->filter(fn(Hobbit $hobbit) => $hobbit === Hobbit::Frodo);
```

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

### Create Options from PHP Enums with Spatie Laravel Options

Source: https://context7.com/spatie/laravel-options/llms.txt

Generates option arrays from native PHP enums, Spatie enums, or MyCLabs enums. Supports automatic label resolution using a static `labels()` method or custom resolution via a closure. Allows filtering options using `only()` and `except()` methods.

```php
use Spatie\LaravelOptions\Options;

enum Hobbit: string
{
    case Frodo = 'frodo';
    case Sam = 'sam';
    case Merry = 'merry';
    case Pippin = 'pippin';

    public static function labels(): array
    {
        return [
            'frodo' => 'Frodo Baggins',
            'sam' => 'Sam Gamgee',
            'merry' => 'Merry Brandybuck',
            'pippin' => 'Pippin Took',
        ];
    }
}

// Basic usage with default label method
$options = Options::forEnum(Hobbit::class)->toArray();
// [
//     ['label' => 'Frodo Baggins', 'value' => 'frodo'],
//     ['label' => 'Sam Gamgee', 'value' => 'sam'],
//     ['label' => 'Merry Brandybuck', 'value' => 'merry'],
//     ['label' => 'Pippin Took', 'value' => 'pippin'],
// ]

// Custom label resolution with closure
$options = Options::forEnum(Hobbit::class, fn(Hobbit $hobbit) => $hobbit->name . ' from the Shire')->toArray();
// [
//     ['label' => 'Frodo from the Shire', 'value' => 'frodo'],
//     ['label' => 'Sam from the Shire', 'value' => 'sam'],
//     ['label' => 'Merry from the Shire', 'value' => 'merry'],
//     ['label' => 'Pippin from the Shire', 'value' => 'pippin'],
// ]

// Filter specific options with only()
$options = Options::forEnum(Hobbit::class)->only(Hobbit::Frodo, Hobbit::Sam)->toArray();
// [['label' => 'Frodo Baggins', 'value' => 'frodo'], ['label' => 'Sam Gamgee', 'value' => 'sam']]

// Exclude specific options with except()
$options = Options::forEnum(Hobbit::class)->except(Hobbit::Frodo, Hobbit::Sam)->toArray();
// [['label' => 'Merry Brandybuck', 'value' => 'merry'], ['label' => 'Pippin Took', 'value' => 'pippin']]

```

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

### Nullable Laravel Validation Rule for Options Enum

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Shows how to create a nullable validation rule for options when the corresponding enum value might be absent. Calling the `nullable()` method before `toValidationRule()` ensures the validation rule includes the 'nullable' attribute.

```php
$request->validate([
    // ['nullable', 'in:frodo,sam,merry,pippin']
    'hobbit' => Options::forEnum(Hobbit::class)->nullable()->toValidationRule()
]);
```

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

### Convert Enum to Options Array in PHP

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Converts a PHP enum into a structured array of options, where each option has a 'label' and 'value'. This is useful for populating select fields in forms.

```php
enum Hobbit: string
{
    case Frodo = 'frodo';
    case Sam = 'sam';
    case Merry = 'merry';
    case Pippin = 'pippin';
}

Options::forEnum(Hobbit::class)->toArray();
```

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

### Generate Options from Enum in PHP

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Creates an Options object from a PHP enum. This object can then be further processed, such as converting to an array or JSON.

```php
Options::forEnum(Hobbit::class);
```

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

### Excluding Specific Enum Options with 'except' in Laravel

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Details the usage of the `except` method to exclude specific enum options from the generated options array. This is complementary to the `only` method.

```php
Options::forEnum(Hobbit::class)->except(Hobbit::Frodo, Hobbit::Sam);
```

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

### Convert Enum to Options JSON in PHP

Source: https://github.com/spatie/laravel-options/blob/main/README.md

Converts a PHP enum into a JSON string representation of options. This is useful for direct use in JavaScript or API responses.

```php
Options::forEnum(Hobbit::class)->toJson();
```
Tokens:
Raw