PHPackages                             blackpig-creatif/atelier - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. blackpig-creatif/atelier

ActiveLibrary[Utility & Helpers](/categories/utility)

blackpig-creatif/atelier
========================

L'art du contenu - Artisanal content blocks for FilamentPHP v5

v2.0.0(1mo ago)029MITPHPPHP ^8.3|^8.4CI failing

Since Feb 9Pushed 1mo agoCompare

[ Source](https://github.com/Blackpig/atelier)[ Packagist](https://packagist.org/packages/blackpig-creatif/atelier)[ Docs](https://github.com/blackpig/atelier)[ RSS](/packages/blackpig-creatif-atelier/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (10)Dependencies (18)Versions (16)Used By (0)

Atelier
=======

[](#atelier)

[![Latest Version on Packagist](https://camo.githubusercontent.com/fe17f87b71d31005d36bfdf743bc6fb4e1d2e1a7c6abe10449676250087d0563/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f626c61636b7069672d637265617469662f6174656c6965722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/blackpig-creatif/atelier)[![Total Downloads](https://camo.githubusercontent.com/ebbe0f19a34b39d222eaae3ebe0ec4356f17fc85db251c3c5c7a6443e958764a/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f626c61636b7069672d637265617469662f6174656c6965722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/blackpig-creatif/atelier)

A polymorphic content block builder for FilamentPHP v5 with first-class translation support, EAV attribute storage, and Schema.org structured data generation.

Atelier stores block data as polymorphic EAV (Entity-Attribute-Value) rows, keeping your application schema lean while supporting arbitrary block structures. Translatable fields are stored per-locale, and the schema is scanned at save time to determine translatability automatically.

Requirements
------------

[](#requirements)

- PHP 8.2+
- Laravel 11+
- FilamentPHP 5.0+

Installation
------------

[](#installation)

```
composer require blackpig-creatif/atelier
```

Atelier automatically pulls in its companion packages:

- [Chambre Noir](https://github.com/blackpig-creatif/chambre-noir) -- responsive image processing

Publish and run migrations:

```
php artisan vendor:publish --tag="atelier-migrations"
php artisan migrate
```

Publish the config:

```
php artisan vendor:publish --tag="atelier-config"
```

Register the Filament plugin in your `PanelProvider`:

```
use BlackpigCreatif\Atelier\AtelierPlugin;

public function panel(Panel $panel): Panel
{
    return $panel
        ->plugins([
            AtelierPlugin::make(),
        ]);
}
```

### Optional Publishables

[](#optional-publishables)

```
# Block Blade templates (recommended -- customise frontend rendering)
php artisan vendor:publish --tag="atelier-block-templates"

# Divider SVG components
php artisan vendor:publish --tag="atelier-dividers"
```

---

Quick Start
-----------

[](#quick-start)

### 1. Add the trait to your model

[](#1-add-the-trait-to-your-model)

```
use BlackpigCreatif\Atelier\Concerns\HasAtelierBlocks;

class Page extends Model
{
    use HasAtelierBlocks;
}
```

This gives you:

```
$page->blocks;            // MorphMany -- all blocks, ordered
$page->publishedBlocks;   // MorphMany -- only is_published = true
$page->renderBlocks();    // string -- rendered HTML of all published blocks
$page->renderBlocks('fr');
```

### 2. Add BlockManager to your Filament resource

[](#2-add-blockmanager-to-your-filament-resource)

```
use BlackpigCreatif\Atelier\Forms\Components\BlockManager;
use BlackpigCreatif\Atelier\Collections\BasicBlocks;

public static function form(Form $form): Form
{
    return $form->schema([
        BlockManager::make('blocks')
            ->blocks(BasicBlocks::class)
            ->collapsible()
            ->reorderable(),
    ]);
}
```

### 3. Render blocks in your view

[](#3-render-blocks-in-your-view)

```
{{-- Blade directive --}}
@renderBlocks($page)

{{-- Or manually --}}
@foreach($page->publishedBlocks as $block)
    {!! $block->render() !!}
@endforeach

{{-- With explicit locale --}}
@foreach($page->publishedBlocks as $block)
    {!! $block->render('fr') !!}
@endforeach
```

---

Built-in Blocks
---------------

[](#built-in-blocks)

BlockDescriptionSchema contribution**HeroBlock**Full-width hero with background image, headline, CTAsNone**TextBlock**Rich text with optional title, subtitle, column layoutArticle body text**TextWithImageBlock**Text + single image, configurable positionArticle body text + image URL**TextWithTwoImagesBlock**Rich text + two images, multiple layout modesArticle body text + image URLs**ImageBlock**Single image with caption, aspect ratio, lightboxNone**VideoBlock**YouTube/Vimeo/direct URL embed with auto-detectionVideoObject schema**GalleryBlock**Grid gallery with configurable columns and lightboxImage URLs for Article**CarouselBlock**Image carousel with navigation and autoplayImage URLs for Article**FaqsBlock**Accordion FAQ listFAQPage schema---

Block Collections
-----------------

[](#block-collections)

Collections group blocks into reusable sets.

### Built-in collections

[](#built-in-collections)

CollectionBlocks`BasicBlocks`Hero, Text, TextWithImage`MediaBlocks`Image, Video, Gallery, Carousel`AllBlocks`All built-in blocks### Usage

[](#usage)

```
// Single collection
->blocks(BasicBlocks::class)

// Multiple collections
->blocks([BasicBlocks::class, MediaBlocks::class])

// Mix collections with individual blocks
->blocks([BasicBlocks::class, CustomBlock::class])

// Closure for dynamic logic
->blocks(fn () => auth()->user()->isAdmin()
    ? AllBlocks::make()
    : BasicBlocks::make()
)
```

### Creating a collection

[](#creating-a-collection)

```
php artisan atelier:make-collection Ecommerce
```

Or manually:

```
namespace App\BlackpigCreatif\Atelier\Collections;

use BlackpigCreatif\Atelier\Abstracts\BaseBlockCollection;
use BlackpigCreatif\Atelier\Blocks\HeroBlock;
use App\BlackpigCreatif\Atelier\Blocks\ProductBlock;

class EcommerceBlocks extends BaseBlockCollection
{
    public function getBlocks(): array
    {
        return [
            HeroBlock::class,
            ProductBlock::class,
        ];
    }

    public static function getLabel(): string
    {
        return 'E-commerce Blocks';
    }
}
```

---

Block Configuration
-------------------

[](#block-configuration)

Atelier supports two layers of configuration: **field configuration** (tweak individual field properties) and **schema modification** (add, remove, or reorder fields structurally). Both can be applied globally or per-resource.

For the full reference with all helper methods and patterns, see [docs/block-configuration.md](docs/block-configuration.md).

### Global Configuration

[](#global-configuration)

Register global defaults in a service provider:

```
namespace App\Providers;

use BlackpigCreatif\Atelier\Blocks\HeroBlock;
use BlackpigCreatif\Atelier\Blocks\TextBlock;
use BlackpigCreatif\Atelier\Support\BlockFieldConfig;
use Filament\Forms\Components\Toggle;
use Illuminate\Support\ServiceProvider;

class AtelierServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        // Configure individual fields
        BlockFieldConfig::configure(TextBlock::class, [
            'subtitle' => ['visible' => false],
            'columns'  => ['options' => ['1' => '1 Column', '2' => '2 Columns']],
        ]);

        // Modify schema structure
        BlockFieldConfig::modifySchema(HeroBlock::class, function ($schema) {
            return BlockFieldConfig::removeFields($schema, ['text_color', 'overlay_opacity']);
        });

        // Add fields
        BlockFieldConfig::modifySchema(HeroBlock::class, function ($schema) {
            return [
                ...$schema,
                Toggle::make('featured')->label('Featured')->default(false),
            ];
        });
    }
}
```

Register it in `bootstrap/providers.php`.

### Per-Resource Configuration

[](#per-resource-configuration)

Override globals on a specific resource:

```
BlockManager::make('blocks')
    ->blocks([HeroBlock::class, TextBlock::class])

    // Field config (array form)
    ->configureBlock(HeroBlock::class, [
        'headline' => ['maxLength' => 60],
        'ctas'     => ['maxItems' => 5],
    ])

    // Schema modifier (closure form)
    ->configureBlock(HeroBlock::class, fn ($schema) =>
        BlockFieldConfig::removeFields($schema, 'subtitle')
    )
```

### Configuration Priority

[](#configuration-priority)

```
Block Default Schema
  -> Global Schema Modifiers
    -> Per-Resource Schema Modifiers
      -> Global Field Configs
        -> Per-Resource Field Configs (wins)

```

Schema modifiers shape the structure first; field configs tweak properties last. Per-resource always overrides global at the same level.

### Fluent API (BlockConfigurator)

[](#fluent-api-blockconfigurator)

For a chainable alternative:

```
use BlackpigCreatif\Atelier\Support\BlockConfigurator;

BlockConfigurator::for(HeroBlock::class)
    ->hide('overlay_opacity', 'text_color')
    ->remove('height')
    ->configure('ctas', ['maxItems' => 2])
    ->insertAfter('headline', [
        TextInput::make('tagline')->maxLength(100),
    ])
    ->apply();
```

---

Creating Custom Blocks
----------------------

[](#creating-custom-blocks)

### Artisan generator

[](#artisan-generator)

```
php artisan atelier:make-block Quote
```

Creates the block class and Blade template with the correct boilerplate.

### Manual creation

[](#manual-creation)

```
namespace App\BlackpigCreatif\Atelier\Blocks;

use BlackpigCreatif\Atelier\Abstracts\BaseBlock;
use BlackpigCreatif\Atelier\Concerns\HasCommonOptions;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Schemas\Components\Section;
use Illuminate\Contracts\View\View;

class QuoteBlock extends BaseBlock
{
    use HasCommonOptions;

    public static function getLabel(): string
    {
        return 'Quote';
    }

    public static function getIcon(): string
    {
        return 'heroicon-o-chat-bubble-left-right';
    }

    public static function getSchema(): array
    {
        return [
            ...static::getHeaderFields(),

            Section::make('Content')
                ->schema([
                    Textarea::make('quote')
                        ->required()
                        ->rows(3)
                        ->translatable(),  // must be last in chain

                    TextInput::make('author')
                        ->required()
                        ->translatable(),  // must be last in chain
                ])
                ->collapsible(),

            ...static::getCommonOptionsSchema(),
        ];
    }

    public function render(): View
    {
        return view(static::getViewPath(), $this->getViewData());
    }
}
```

Key points:

- Extend `BaseBlock` and implement `getLabel()`, `getSchema()`, `render()`
- Use `HasCommonOptions` for background, spacing, width, and divider controls
- Call `->translatable()` as the **last** method in a field chain
- Call `...static::getHeaderFields()` at the top of your schema (Published toggle + Fragment ID when scroll navigation is enabled)
- Call `...static::getCommonOptionsSchema()` at the end for display options

### Block template

[](#block-template)

Templates live at `resources/views/vendor/atelier/blocks/{block-identifier}.blade.php`. See [docs/block-templates.md](docs/block-templates.md) for the full template guide.

```
@php
    $blockIdentifier = 'atelier-' . $block::getBlockIdentifier();
@endphp

        @if($quote = $block->getTranslated('quote'))

                "{{ $quote }}"

        @endif

        @if($author = $block->getTranslated('author'))
            -- {{ $author }}
        @endif

    @if($block->getDividerComponent())

    @endif

```

---

Translation
-----------

[](#translation)

Atelier provides inline, per-field translation with a global locale switcher in the block modal.

### Making fields translatable

[](#making-fields-translatable)

Append `->translatable()` as the **last** call in the field chain:

```
TextInput::make('headline')
    ->required()
    ->maxLength(255)
    ->translatable();
```

The macro clones the field for each configured locale, wrapping them in a group that responds to the global locale selector via Alpine.js.

### Schema scanning

[](#schema-scanning)

Atelier automatically detects translatable fields by scanning the block schema at save time. You do not need to maintain a `getTranslatableFields()` method. If you do define one, it is used as a performance optimisation on the frontend to avoid schema scanning on render.

### Retrieving translated values

[](#retrieving-translated-values)

```
// In templates
$block->getTranslated('headline');         // current locale
$block->getTranslated('headline', 'fr');   // explicit locale
```

### Configuration

[](#configuration)

In `config/atelier.php`:

```
'locales' => [
    'en' => 'English',
    'fr' => 'Francais',
],

'default_locale' => 'en',
```

Data is stored as one EAV row per locale per field: `headline/en`, `headline/fr`.

---

Call to Actions (CTAs)
----------------------

[](#call-to-actions-ctas)

The `HasCallToActions` trait adds a repeater-based CTA system to any block.

### Adding CTAs

[](#adding-ctas)

```
use BlackpigCreatif\Atelier\Concerns\HasCallToActions;

class HeroBlock extends BaseBlock
{
    use HasCallToActions;

    public static function getSchema(): array
    {
        return [
            // ... content fields

            Section::make('Call to Action')
                ->schema([
                    static::getCallToActionsField()
                        ->maxItems(3),
                ])
                ->collapsible(),
        ];
    }
}
```

Each CTA item includes: **label** (translatable), **url**, **icon** (Heroicon name), **style** (from config), **new\_tab** toggle.

### Rendering

[](#rendering)

```
@if($block->hasCallToActions())

        @foreach($block->getCallToActions() as $index => $cta)

        @endforeach

@endif
```

### Helper methods

[](#helper-methods)

```
$block->hasCallToActions(): bool
$block->getCallToActions(): array
$block->getCallToActionLabel($cta, ?string $locale): string
$block->getCallToActionStyleClass($cta): string
$block->getCallToActionTarget($cta): string   // '_blank' or '_self'
$block->isExternalUrl(string $url): bool
```

### Button styles

[](#button-styles)

Configured in `config/atelier.php`:

```
'features' => [
    'button_styles' => [
        'enabled' => true,
        'options' => [
            'primary'   => ['label' => 'Primary',   'class' => 'btn btn-primary'],
            'secondary' => ['label' => 'Secondary', 'class' => 'btn btn-secondary'],
            'alternate' => ['label' => 'Alternate', 'class' => 'btn btn-alternate'],
        ],
    ],
],
```

---

Display Options
---------------

[](#display-options)

All blocks using `HasCommonOptions` gain a collapsible "Display Options" section with:

FeatureDescriptionConfig key**Background**Predefined background colours (Tailwind classes + admin colour swatch)`features.backgrounds`**Spacing**Balanced (equal `py-`) or individual (`pt-` / `pb-`) vertical padding`features.spacing`**Width**Container, Narrow, Wide, or Full Width content constraint`features.width`**Dividers**Decorative SVG dividers (wave, curve, diagonal, triangle) with colour transition to next section`features.dividers`**Published**Toggle to show/hide on frontend (`is_published` column)--In templates, use `$block->getWrapperClasses()` on the outer `` (background + spacing) and `$block->getContainerClasses()` on the inner `` (width constraint).

---

Scroll Navigation
-----------------

[](#scroll-navigation)

Atelier includes optional in-page scroll navigation, designed for single-page sites with a fixed header nav that links to named sections.

Enable it in `config/atelier.php`:

```
'features' => [
    'scroll_navigation' => [
        'enabled' => true,
        'offset'  => 80, // fixed nav height in pixels
    ],
],
```

When enabled, a **Fragment ID** field appears alongside the Published toggle at the top of every block's edit form. Editors enter a short identifier (e.g. `about`) and the rendered `` receives `id="about"`.

### JS helper

[](#js-helper)

The `scrollToEl()` helper is injected once per page via `@push('scripts')` when any block is rendered. Add `@stack('scripts')` before `` in your layout if it is not already there.

```
window.scrollToEl = (selector) => {
    const el = document.getElementById(selector)
    if (!el) return
    const y = el.getBoundingClientRect().top + window.scrollY - 80 // offset from config
    window.scrollTo({ top: y, behavior: 'smooth' })
}
```

### Wiring up nav links

[](#wiring-up-nav-links)

```

About

About
```

### Template method

[](#template-method)

```
$block->getFragmentId(): ?string   // returns the stored value, or null if unset
```

---

Media Handling
--------------

[](#media-handling)

Atelier integrates with [Chambre Noir](https://github.com/blackpig-creatif/chambre-noir) for responsive images. Use `RetouchMediaUpload` in your schema and the `HasRetouchMedia` trait on your block:

```
use BlackpigCreatif\ChambreNoir\Concerns\HasRetouchMedia;
use BlackpigCreatif\ChambreNoir\Forms\Components\RetouchMediaUpload;
use BlackpigCreatif\Atelier\Conversions\BlockHeroConversion;

class HeroBlock extends BaseBlock
{
    use HasRetouchMedia;

    public static function getSchema(): array
    {
        return [
            RetouchMediaUpload::make('background_image')
                ->preset(BlockHeroConversion::class)
                ->imageEditor()
                ->maxFiles(1),
        ];
    }
}
```

In templates:

```
{!! $block->getPicture('background_image', [
    'alt'           => $block->getTranslated('headline'),
    'class'         => 'w-full h-full object-cover',
    'fetchpriority' => 'high',
]) !!}
```

### Built-in conversion presets

[](#built-in-conversion-presets)

PresetConversionsUse case`BlockHeroConversion`thumb, medium, large, desktop, mobile + social (og, twitter)Hero sections, full-width banners`BlockGalleryConversion`thumb, medium, largeGalleries, content images, carousels### Extracting images from blocks

[](#extracting-images-from-blocks)

The `HasAtelierMediaExtraction` trait (add to your model) provides convenience methods:

```
use BlackpigCreatif\Atelier\Concerns\HasAtelierMediaExtraction;

class Page extends Model
{
    use HasAtelierBlocks, HasAtelierMediaExtraction;
}

$page->getHeroImageFromBlocks('large');
$page->getImageFromBlock('image', 'medium', ImageBlock::class);
```

---

SEO Schema Generation
---------------------

[](#seo-schema-generation)

Atelier exposes three PHP contracts that blocks implement to contribute to Schema.org output. The contracts are deliberately package-agnostic — Atelier has no dependency on Sceau or any other SEO library.

See [docs/schema.md](docs/schema.md) for the full reference.

### Three schema contracts

[](#three-schema-contracts)

`BaseBlock` implements all three contracts with no-op defaults. Override only what your block needs.

**`HasCompositeSchema`** — contributes content or media URLs to a composite schema (e.g. Article) assembled from multiple blocks:

```
public function contributesToComposite(): bool { return true; }

public function getCompositeContribution(): array
{
    return [
        'type'    => 'text',
        'content' => strip_tags($this->getTranslated('content') ?? ''),
    ];
}
```

**`HasSchemaContribution`** — declares a typed schema that the active driver converts to a structured data array:

```
use BlackpigCreatif\Sceau\Enums\SchemaType;

public function getSchemaType(): ?SchemaType
{
    return ! empty($this->get('faqs')) ? SchemaType::FAQPage : null;
}

public function getSchemaData(): array
{
    return ['faqs' => $this->get('faqs', [])];
}
```

**`HasStandaloneSchema`** — legacy escape hatch for blocks that build the full schema array themselves. Prefer the driver pattern for new blocks.

### Wiring a driver

[](#wiring-a-driver)

The driver is resolved from the container via `BlockSchemaDriverInterface`. Configure Sceau's driver in your app config:

```
// config/atelier.php
'schema_driver' => \BlackpigCreatif\Sceau\Schema\Drivers\SceauBlockSchemaDriver::class,
```

When using Sceau, schema generation is fully automatic — the `` component calls `PageSchemaBuilder::build()` for models that carry `HasAtelierBlocks`.

---

Configuration Reference
-----------------------

[](#configuration-reference)

The `config/atelier.php` file:

```
return [
    'locales'        => ['en' => 'English', 'fr' => 'Francais'],
    'default_locale' => 'en',

    'modal' => ['width' => '5xl'],

    'table_prefix' => 'atelier_',

    'blocks' => [
        // Default blocks when ->blocks() is called without arguments
    ],

    'schema_driver' => null, // Set to a BlockSchemaDriverInterface class to enable schema generation

    'features' => [
        'backgrounds'       => ['enabled' => true,  'options' => [...]],
        'spacing'           => ['enabled' => true,  'options' => [...]],
        'width'             => ['enabled' => true,  'options' => [...]],
        'dividers'          => ['enabled' => true,  'options' => [...]],
        'button_styles'     => ['enabled' => true,  'options' => [...]],
        'scroll_navigation' => ['enabled' => false, 'offset'  => 80],
    ],

    'cache' => [
        'enabled' => true,
        'ttl'     => 3600,
        'prefix'  => 'atelier_block_',
    ],
];
```

---

Architecture
------------

[](#architecture)

Atelier uses a polymorphic EAV storage model:

- **`atelier_blocks`** -- polymorphic (`blockable_type`, `blockable_id`), stores block type, position, UUID, published status
- **`atelier_block_attributes`** -- stores each field value as a row with `key`, `value`, `type`, `locale`, `translatable`, `sort_order`, `collection_name`, `collection_index`

Repeater fields (e.g. CTAs) are stored as collection-based EAV rows, grouped by `collection_name` and `collection_index`.

At hydration time, the `AtelierBlock` model reconstructs the block instance, fills its data array, and caches the result per locale.

---

Documentation
-------------

[](#documentation)

- [Block Configuration](docs/block-configuration.md) -- full field config and schema modification reference
- [Block Templates](docs/block-templates.md) -- template structure, helper methods, scroll navigation, best practices
- [Schema Generation](docs/schema.md) -- schema contracts, built-in contributions, custom block schemas

---

Testing
-------

[](#testing)

```
composer test
```

Changelog
---------

[](#changelog)

See [CHANGELOG](docs/CHANGELOG.md).

Credits
-------

[](#credits)

- [Stuart Hallewell](https://github.com/blackpig-creatif)
- [All Contributors](../../contributors)

License
-------

[](#license)

MIT. See [LICENSE](docs/LICENSE.md).

###  Health Score

44

—

FairBetter than 92% of packages

Maintenance90

Actively maintained with recent releases

Popularity10

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity59

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~5 days

Total

11

Last Release

46d ago

Major Versions

v1.2.1 → v2.0.02026-04-01

PHP version history (2 changes)v1.0.0PHP ^8.2|^8.3|^8.4

v2.0.0PHP ^8.3|^8.4

### Community

Maintainers

![](https://www.gravatar.com/avatar/e094a144c7d16d2115fac66e49bf5013829a545f111c618ff22fe11ddf8c7bf4?d=identicon)[Blackpig](/maintainers/Blackpig)

---

Top Contributors

[![Blackpig](https://avatars.githubusercontent.com/u/1029317?v=4)](https://github.com/Blackpig "Blackpig (12 commits)")

---

Tags

laravelcmsblockscontent managementfilamentfilamentphppage builderblackpig-creatifatelier

###  Code Quality

TestsPest

### Embed Badge

![Health badge](/badges/blackpig-creatif-atelier/health.svg)

```
[![Health](https://phpackages.com/badges/blackpig-creatif-atelier/health.svg)](https://phpackages.com/packages/blackpig-creatif-atelier)
```

###  Alternatives

[dotswan/filament-map-picker

Easily pick and retrieve geo-coordinates using a map-based interface in your Filament applications.

124139.3k2](/packages/dotswan-filament-map-picker)[pboivin/filament-peek

Full-screen page preview modal for Filament

253319.6k12](/packages/pboivin-filament-peek)[creagia/filament-code-field

A Filamentphp input field to edit or view code data.

58289.3k3](/packages/creagia-filament-code-field)[jibaymcs/filament-tour

Bring the power of DriverJs to your Filament panels and start a tour !

12247.8k](/packages/jibaymcs-filament-tour)[swisnl/filament-backgrounds

Beautiful backgrounds for Filament auth pages

54149.2k6](/packages/swisnl-filament-backgrounds)[tapp/filament-google-autocomplete-field

Filament plugin that provides a Google Autocomplete field

3098.1k](/packages/tapp-filament-google-autocomplete-field)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)