Ehsan Bagherzadegan
Back to articles
4 min read

Filament v5.11: Building Custom Fields, Components, and Widgets with JavaScript

Filament v5.11 introduces first-class JavaScript extensibility — write form fields, schema components, and dashboard widgets in React, Vue, Svelte, or vanilla JS, compiled with Vite and integrated via a shared renderer foundation.

Filament v5.11, released on October 26, 2026, introduces a significant architectural shift: first-class support for building custom form fields, schema components, and widgets with JavaScript. You can now write these pieces in React, Vue, Svelte, or framework-free JavaScript, compile them with Vite, and drop them into your Filament panels without leaving the PHP ecosystem.

This isn't a replacement for PHP components. Filament and Livewire still own state, validation, and HTTP. The JavaScript layer only handles rendering and interaction. But for complex inputs — map pickers, chart visualizations, rich text editors, or anything that needs a mature JS ecosystem — it removes the friction of bridging Alpine or raw JavaScript into Blade partials.

The Three New Primitives

Primitive Generator Command Base Class Use Case
Form Field make:filament-form-field JsField Inputs that participate in form state, validation, and submission
Schema Component make:filament-schema-component JsComponent Read-only or interactive UI in infolists, tables, or custom schemas
Widget make:filament-widget HasJsRenderer trait Dashboard widgets that can call back into PHP

All three share the same renderer foundation: a Vite-compiled ES module that exports a mount function receiving { host, props, utilities } and returning { update, destroy }.

JavaScript Custom Fields

Form fields are the most common extension point. The generator scaffolds a PHP class and a renderer entry point:

php artisan make:filament-form-field LocationPicker --react
# or --vue, --svelte, --js
php artisan make:filament-form-field LocationPicker --react --typescript

This creates:

  • app/Filament/Fields/LocationPicker.php extending JsField
  • resources/js/fields/location-picker.jsx (or .vue, .svelte, .js)
  • Vite entry configuration in vite.config.js

Using JsField Directly

For one-off fields, skip the PHP class and use JsField inline:

use Filament\Forms\Components\JsField;
use Illuminate\Support\Facades\Vite;

JsField::make('location')
    ->renderer(Vite::asset('resources/js/fields/location-picker.jsx'))
    ->default(['latitude' => 51.5074, 'longitude' => -0.1278])
    ->live(onBlur: true); // or live(debounce: 500)

The Renderer Contract

Every field renderer receives props containing the field's current state and callbacks:

// props shape (TypeScript types from @filament/forms/js-field)
interface FieldProps {
    id: string;
    value: unknown;              // JSON-serializable current value
    isDisabled: boolean;
    isReadOnly: boolean;
    isRequired: boolean;
    isInvalid: boolean;
    ariaDescribedBy: string | null;
    onChange: (value: unknown) => void;
    onBlur: () => void;
}

A framework-free example:

// resources/js/fields/location-picker.js
export default function mountLocationPicker({ host, props: initialProps }) {
    const input = document.createElement('input');
    input.type = 'text';
    input.value = initialProps.value ?? '';
    input.disabled = initialProps.isDisabled;
    input.required = initialProps.isRequired;
    input.id = initialProps.id;
    input.setAttribute('aria-describedby', initialProps.ariaDescribedBy ?? '');

    input.addEventListener('input', (e) => {
        initialProps.onChange(e.target.value);
    });
    input.addEventListener('blur', initialProps.onBlur);

    host.appendChild(input);

    return {
        update(props) {
            input.value = props.value ?? '';
            input.disabled = props.isDisabled;
            input.required = props.isRequired;
            input.setAttribute('aria-invalid', props.isInvalid);
        },
        destroy() {
            host.replaceChildren();
        },
    };
}

React, Vue, and Svelte renderers follow the same pattern but use their respective mounting APIs (createRoot, createApp, mount). The generated scaffold includes a working example for each framework.

Live Updates

The live() method controls when onChange fires:

  • live() — on every change (like wire:model.live)
  • live(onBlur: true) — only on blur
  • live(debounce: 500) — debounced by 500 ms

This mirrors Livewire's behavior and keeps server round-trips predictable.

Passing Configuration from PHP

Use extraAttributes or custom methods on your field class to pass data to the renderer:

class LocationPicker extends JsField
{
    protected string $renderer = 'resources/js/fields/location-picker.jsx';

    public function mapStyle(string $style): static
    {
        $this->extraAttributes['data-map-style'] = $style;
        return $this;
    }
}

The renderer receives these via props.extraAttributes.

JavaScript Schema Components

Schema components render inside infolists, tables, or custom schema layouts. They do not participate in form state — no onChange, no validation. Instead, they receive a rendererConfiguration payload and a set of schema utilities.

Generate one with:

php artisan make:filament-schema-component SalesChart --vue --typescript

Using JsComponent Directly

use Filament\Schemas\Components\JsComponent;
use Illuminate\Support\Facades\Vite;

JsComponent::make()
    ->key('sales-summary')
    ->renderer(Vite::asset('resources/js/components/sales-chart.vue'))
    ->rendererConfiguration([
        'period' => 'month',
        'currency' => 'EUR',
    ]);

The Renderer Contract

Schema component renderers receive props.configuration (your JSON-serializable config) and utilities for schema interaction:

interface SchemaUtilities {
    $get: (path: string) => unknown;
    $set: (path: string, value: unknown) => void;
    $callSchemaComponentMethod: (key: string, method: string, ...args: unknown[]) => Promise