🆙 Add cms i using 🆙

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/02-text.md

@@ -0,0 +1,753 @@
+---
+title: Text column
+---
+import Aside from "@components/Aside.astro"
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+Text columns display simple text:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('title')
+```
+
+<AutoScreenshot name="tables/columns/text/simple" alt="Text column" version="4.x" />
+
+## Customizing the color
+
+You may set a [color](../../styling/colors) for the text:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('status')
+    ->color('primary')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `color()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/color" alt="Text column in the primary color" version="4.x" />
+
+## Adding an icon
+
+Text columns may also have an [icon](../../styling/icons):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Filament\Support\Icons\Heroicon;
+
+TextColumn::make('email')
+    ->icon(Heroicon::Envelope)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The `icon()` method also accepts a function to dynamically calculate the icon. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/icon" alt="Text column with icon" version="4.x" />
+
+You may set the position of an icon using `iconPosition()`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Filament\Support\Enums\IconPosition;
+use Filament\Support\Icons\Heroicon;
+
+TextColumn::make('email')
+    ->icon(Heroicon::Envelope)
+    ->iconPosition(IconPosition::After) // `IconPosition::Before` or `IconPosition::After`
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The `iconPosition()` method also accepts a function to dynamically calculate the icon position. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/icon-after" alt="Text column with icon after" version="4.x" />
+
+The icon color defaults to the text color, but you may customize the icon [color](../../styling/colors) separately using `iconColor()`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Filament\Support\Icons\Heroicon;
+
+TextColumn::make('email')
+    ->icon(Heroicon::Envelope)
+    ->iconColor('primary')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The `iconColor()` method also accepts a function to dynamically calculate the icon color. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/icon-color" alt="Text column with icon in the primary color" version="4.x" />
+
+## Displaying as a "badge"
+
+By default, text is quite plain and has no background color. You can make it appear as a "badge" instead using the `badge()` method. A great use case for this is with statuses, where may want to display a badge with a [color](#customizing-the-color) that matches the status:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('status')
+    ->badge()
+    ->color(fn (string $state): string => match ($state) {
+        'draft' => 'gray',
+        'reviewing' => 'warning',
+        'published' => 'success',
+        'rejected' => 'danger',
+    })
+```
+
+<AutoScreenshot name="tables/columns/text/badge" alt="Text column as badge" version="4.x" />
+
+You may add other things to the badge, like an [icon](#adding-an-icon).
+
+Optionally, you may pass a boolean value to control if the text should be in a badge or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('status')
+    ->badge(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `badge()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Formatting
+
+When using a text column, you may want the actual outputted text in the UI to differ from the raw [state](overview#column-content-state) of the column, which is often automatically retrieved from an Eloquent model. Formatting the state allows you to preserve the integrity of the raw data while also allowing it to be presented in a more user-friendly way.
+
+To format the state of a text column without changing the state itself, you can use the `formatStateUsing()` method. This method accepts a function that takes the state as an argument and returns the formatted state:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('status')
+    ->formatStateUsing(fn (string $state): string => __("statuses.{$state}"))
+```
+
+In this case, the `status` column in the database might contain values like `draft`, `reviewing`, `published`, or `rejected`, but the formatted state will be the translated version of these values.
+
+<UtilityInjection set="tableColumns" version="4.x">The function passed to `formatStateUsing()` can inject various utilities as parameters.</UtilityInjection>
+
+### Date formatting
+
+Instead of passing a function to `formatStateUsing()`, you may use the `date()`, `dateTime()`, and `time()` methods to format the column's state using [PHP date formatting tokens](https://www.php.net/manual/en/datetime.format.php):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->date()
+
+TextColumn::make('created_at')
+    ->dateTime()
+
+TextColumn::make('created_at')
+    ->time()
+```
+
+You may customize the date format by passing a custom format string to the `date()`, `dateTime()`, or `time()` method. You may use any [PHP date formatting tokens](https://www.php.net/manual/en/datetime.format.php):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->date('M j, Y')
+    
+TextColumn::make('created_at')
+    ->dateTime('M j, Y H:i:s')
+    
+TextColumn::make('created_at')
+    ->time('H:i:s')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `date()`, `dateTime()`, and `time()` methods also accept a function to dynamically calculate the format. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Date formatting using Carbon macro formats
+
+You may use also the `isoDate()`, `isoDateTime()`, and `isoTime()` methods to format the column's state using [Carbon's macro-formats](https://carbon.nesbot.com/docs/#available-macro-formats):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->isoDate()
+
+TextColumn::make('created_at')
+    ->isoDateTime()
+
+TextColumn::make('created_at')
+    ->isoTime()
+```
+
+You may customize the date format by passing a custom macro format string to the `isoDate()`, `isoDateTime()`, or `isoTime()` method. You may use any [Carbon's macro-formats](https://carbon.nesbot.com/docs/#available-macro-formats):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->isoDate('L')
+
+TextColumn::make('created_at')
+    ->isoDateTime('LLL')
+
+TextColumn::make('created_at')
+    ->isoTime('LT')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `isoDate()`, `isoDateTime()`, and `isoTime()` methods also accept a function to dynamically calculate the format. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Relative date formatting
+
+You may use the `since()` method to format the column's state using [Carbon's `diffForHumans()`](https://carbon.nesbot.com/docs/#api-humandiff):
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->since()
+```
+
+#### Displaying a formatting date in a tooltip
+
+Additionally, you can use the `dateTooltip()`, `dateTimeTooltip()`, `timeTooltip()`, `isoDateTooltip()`, `isoDateTimeTooltip()`, `isoTime()`, `isoTimeTooltip()`, or `sinceTooltip()` method to display a formatted date in a [tooltip](overview#adding-a-tooltip-to-an-column), often to provide extra information:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->since()
+    ->dateTooltip() // Accepts a custom PHP date formatting string
+
+TextColumn::make('created_at')
+    ->since()
+    ->dateTimeTooltip() // Accepts a custom PHP date formatting string
+
+TextColumn::make('created_at')
+    ->since()
+    ->timeTooltip() // Accepts a custom PHP date formatting string
+
+TextColumn::make('created_at')
+    ->since()
+    ->isoDateTooltip() // Accepts a custom Carbon macro format string
+
+TextColumn::make('created_at')
+    ->since()
+    ->isoDateTimeTooltip() // Accepts a custom Carbon macro format string
+
+TextColumn::make('created_at')
+    ->since()
+    ->isoTimeTooltip() // Accepts a custom Carbon macro format string
+
+TextColumn::make('created_at')
+    ->dateTime()
+    ->sinceTooltip()
+```
+
+#### Setting the timezone for date formatting
+
+Each of the date formatting methods listed above also accepts a `timezone` argument, which allows you to convert the time set in the state to a different timezone:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->dateTime(timezone: 'America/New_York')
+```
+
+You can also pass a timezone to the `timezone()` method of the column to apply a timezone to all date-time formatting methods at once:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('created_at')
+    ->timezone('America/New_York')
+    ->dateTime()
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `timezone()` method also accepts a function to dynamically calculate the timezone. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+If you do not pass a `timezone()` to the column, it will use Filament's default timezone. You can set Filament's default timezone using the `FilamentTimezone::set()` method in the `boot()` method of a service provider such as `AppServiceProvider`:
+
+```php
+use Filament\Support\Facades\FilamentTimezone;
+
+public function boot(): void
+{
+    FilamentTimezone::set('America/New_York');
+}
+```
+
+This is useful if you want to set a default timezone for all text columns in your application. It is also used in other places where timezones are used in Filament.
+
+<Aside variant="warning">
+    Filament's default timezone will only apply when the column stores a time. If the column stores a date only (`date()` instead of `dateTime()`), the timezone will not be applied. This is to prevent timezone shifts when storing dates without times.
+</Aside>
+
+### Number formatting
+
+Instead of passing a function to `formatStateUsing()`, you can use the `numeric()` method to format a column as a number:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('stock')
+    ->numeric()
+```
+
+If you would like to customize the number of decimal places used to format the number with, you can use the `decimalPlaces` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('stock')
+    ->numeric(decimalPlaces: 0)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `decimalPlaces` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+By default, your app's locale will be used to format the number suitably. If you would like to customize the locale used, you can pass it to the `locale` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('stock')
+    ->numeric(locale: 'nl')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `locale` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Money formatting
+
+Instead of passing a function to `formatStateUsing()`, you can use the `money()` method to easily format amounts of money, in any currency:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('price')
+    ->money('EUR')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `money()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+There is also a `divideBy` argument for `money()` that allows you to divide the original value by a number before formatting it. This could be useful if your database stores the price in cents, for example:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('price')
+    ->money('EUR', divideBy: 100)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `divideBy` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+By default, your app's locale will be used to format the money suitably. If you would like to customize the locale used, you can pass it to the `locale` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('price')
+    ->money('EUR', locale: 'nl')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `locale` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+If you would like to customize the number of decimal places used to format the number with, you can use the `decimalPlaces` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('price')
+    ->money('EUR', decimalPlaces: 3)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `decimalPlaces` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Rendering Markdown
+
+If your column value is Markdown, you may render it using `markdown()`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->markdown()
+```
+
+Optionally, you may pass a boolean value to control if the text should be rendered as Markdown or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->markdown(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `markdown()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Rendering HTML
+
+If your column value is HTML, you may render it using `html()`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->html()
+```
+
+Optionally, you may pass a boolean value to control if the text should be rendered as HTML or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->html(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `html()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Rendering raw HTML without sanitization
+
+If you use this method, then the HTML will be sanitized to remove any potentially unsafe content before it is rendered. If you'd like to opt out of this behavior, you can wrap the HTML in an `HtmlString` object by formatting it:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Illuminate\Support\HtmlString;
+
+TextColumn::make('description')
+    ->formatStateUsing(fn (string $state): HtmlString => new HtmlString($state))
+```
+
+<Aside variant="danger">
+    Be cautious when rendering raw HTML, as it may contain malicious content, which can lead to security vulnerabilities in your app such as cross-site scripting (XSS) attacks. Always ensure that the HTML you are rendering is safe before using this method.
+</Aside>
+
+Alternatively, you can return a `view()` object from the `formatStateUsing()` method, which will also not be sanitized:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Illuminate\Contracts\View\View;
+
+TextColumn::make('description')
+    ->formatStateUsing(fn (string $state): View => view(
+        'filament.tables.columns.description-column-content',
+        ['state' => $state],
+    ))
+```
+
+## Displaying a description
+
+Descriptions may be used to easily render additional text above or below the column contents.
+
+You can display a description below the contents of a text column using the `description()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('title')
+    ->description(fn (Post $record): string => $record->description)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The function passed to `description()` can inject various utilities as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/description" alt="Text column with description" version="4.x" />
+
+By default, the description is displayed below the main text, but you can move it using `'above'` as the second parameter:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('title')
+    ->description(fn (Post $record): string => $record->description, position: 'above')
+```
+
+<AutoScreenshot name="tables/columns/text/description-above" alt="Text column with description above the content" version="4.x" />
+
+## Listing multiple values
+
+Multiple values can be rendered in a text column if its [state](overview#column-content-state) is an array. This can happen if you are using an `array` cast on an Eloquent attribute, an Eloquent relationship with multiple results, or if you have passed an array to the [`state()` method](overview#setting-the-state-of-an-column). If there are multiple values inside your text column, they will be comma-separated. You may use the `listWithLineBreaks()` method to display them on new lines instead:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->listWithLineBreaks()
+```
+
+Optionally, you may pass a boolean value to control if the text should have line breaks between each item or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->listWithLineBreaks(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `listWithLineBreaks()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Adding bullet points to the list
+
+You may add a bullet point to each list item using the `bulleted()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->bulleted()
+```
+
+Optionally, you may pass a boolean value to control if the text should have bullet points or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->bulleted(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `bulleted()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Limiting the number of values in the list
+
+You can limit the number of values in the list using the `limitList()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->listWithLineBreaks()
+    ->limitList(3)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `limitList()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Expanding the limited list
+
+You can allow the limited items to be expanded and collapsed, using the `expandableLimitedList()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->listWithLineBreaks()
+    ->limitList(3)
+    ->expandableLimitedList()
+```
+
+<Aside variant="info">
+    This is only a feature for `listWithLineBreaks()` or `bulleted()`, where each item is on its own line.
+</Aside>
+
+Optionally, you may pass a boolean value to control if the text should be expandable or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('authors.name')
+    ->listWithLineBreaks()
+    ->limitList(3)
+    ->expandableLimitedList(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `expandableLimitedList()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Splitting a single value into multiple list items
+
+If you want to "explode" a text string from your model into multiple list items, you can do so with the `separator()` method. This is useful for displaying comma-separated tags [as badges](#displaying-as-a-badge), for example:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('tags')
+    ->badge()
+    ->separator(',')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `separator()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Customizing the text size
+
+Text columns have small font size by default, but you may change this to `TextSize::ExtraSmall`, `TextSize::Medium`, or `TextSize::Large`.
+
+For instance, you may make the text larger using `size(TextSize::Large)`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Filament\Support\Enums\TextSize;
+
+TextColumn::make('title')
+    ->size(TextSize::Large)
+```
+
+<AutoScreenshot name="tables/columns/text/large" alt="Text column in a large font size" version="4.x" />
+
+## Customizing the font weight
+
+Text columns have regular font weight by default, but you may change this to any of the following options: `FontWeight::Thin`, `FontWeight::ExtraLight`, `FontWeight::Light`, `FontWeight::Medium`, `FontWeight::SemiBold`, `FontWeight::Bold`, `FontWeight::ExtraBold` or `FontWeight::Black`.
+
+For instance, you may make the font bold using `weight(FontWeight::Bold)`:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+use Filament\Support\Enums\FontWeight;
+
+TextColumn::make('title')
+    ->weight(FontWeight::Bold)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `weight()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/bold" alt="Text column in a bold font" version="4.x" />
+
+## Customizing the font family
+
+You can change the text font family to any of the following options: `FontFamily::Sans`, `FontFamily::Serif` or `FontFamily::Mono`.
+
+For instance, you may make the font monospaced using `fontFamily(FontFamily::Mono)`:
+
+```php
+use Filament\Support\Enums\FontFamily;
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('email')
+    ->fontFamily(FontFamily::Mono)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `fontFamily()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/text/mono" alt="Text column in a monospaced font" version="4.x" />
+
+## Handling long text
+
+### Limiting text length
+
+You may `limit()` the length of the column's value:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->limit(50)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `limit()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+By default, when text is truncated, an ellipsis (`...`) is appended to the end of the text. You may customize this by passing a custom string to the `end` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->limit(50, end: ' (more)')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `end` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+You may also reuse the value that is being passed to `limit()` in a function, by getting it using the `getCharacterLimit()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->limit(50)
+    ->tooltip(function (TextColumn $column): ?string {
+        $state = $column->getState();
+
+        if (strlen($state) <= $column->getCharacterLimit()) {
+            return null;
+        }
+
+        // Only render the tooltip if the column contents exceeds the length limit.
+        return $state;
+    })
+```
+
+### Limiting word count
+
+You may limit the number of `words()` displayed in the column:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->words(10)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `words()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+By default, when text is truncated, an ellipsis (`...`) is appended to the end of the text. You may customize this by passing a custom string to the `end` argument:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->words(10, end: ' (more)')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `end` argument also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Allowing text wrapping
+
+By default, text will not wrap to the next line if it exceeds the width of the container. You can enable this behavior using the `wrap()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->wrap()
+```
+
+Optionally, you may pass a boolean value to control if the text should wrap or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->wrap(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `wrap()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Limiting text to a specific number of lines
+
+You may want to limit text to a specific number of lines instead of limiting it to a fixed length. Clamping text to a number of lines is useful in responsive interfaces where you want to ensure a consistent experience across all screen sizes. This can be achieved using the `lineClamp()` method:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('description')
+    ->wrap()
+    ->lineClamp(2)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `lineClamp()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Allowing the text to be copied to the clipboard
+
+You may make the text copyable, such that clicking on the column copies the text to the clipboard, and optionally specify a custom confirmation message and duration in milliseconds:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('email')
+    ->copyable()
+    ->copyMessage('Email address copied')
+    ->copyMessageDuration(1500)
+```
+
+<AutoScreenshot name="tables/columns/text/copyable" alt="Text column with a button to copy it" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the text should be copyable or not:
+
+```php
+use Filament\Tables\Columns\TextColumn;
+
+TextColumn::make('email')
+    ->copyable(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `copyable()`, `copyMessage()`, and `copyMessageDuration()` methods also accept functions to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<Aside variant="warning">
+    This feature only works when SSL is enabled for the app.
+</Aside>

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/03-icon.md

@@ -0,0 +1,147 @@
+---
+title: Icon column
+---
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import Aside from "@components/Aside.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+Icon columns render an [icon](../../styling/icons) representing the state of the column:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+use Filament\Support\Icons\Heroicon;
+
+IconColumn::make('status')
+    ->icon(fn (string $state): Heroicon => match ($state) {
+        'draft' => Heroicon::OutlinedPencil,
+        'reviewing' => Heroicon::OutlinedClock,
+        'published' => Heroicon::OutlinedCheckCircle,
+    })
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The `icon()` method can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/icon/simple" alt="Icon column" version="4.x" />
+
+## Customizing the color
+
+You may change the [color](../../styling/colors) of the icon, using the `color()` method:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('status')
+    ->color('success')
+```
+
+By passing a function to `color()`, you can customize the color based on the state of the column:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('status')
+    ->color(fn (string $state): string => match ($state) {
+        'draft' => 'info',
+        'reviewing' => 'warning',
+        'published' => 'success',
+        default => 'gray',
+    })
+```
+
+<UtilityInjection set="tableColumns" version="4.x">The `color()` method can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/icon/color" alt="Icon column with color" version="4.x" />
+
+## Customizing the size
+
+The default icon size is `IconSize::Large`, but you may customize the size to be either `IconSize::ExtraSmall`, `IconSize::Small`, `IconSize::Medium`, `IconSize::ExtraLarge` or `IconSize::TwoExtraLarge`:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+use Filament\Support\Enums\IconSize;
+
+IconColumn::make('status')
+    ->size(IconSize::Medium)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `size()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/icon/medium" alt="Medium-sized icon column" version="4.x" />
+
+## Handling booleans
+
+Icon columns can display a check or "X" icon based on the state of the column, either true or false, using the `boolean()` method:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('is_featured')
+    ->boolean()
+```
+
+> If this attribute in the model class is already cast as a `bool` or `boolean`, Filament is able to detect this, and you do not need to use `boolean()` manually.
+
+<AutoScreenshot name="tables/columns/icon/boolean" alt="Icon column to display a boolean" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the icon should be boolean or not:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('is_featured')
+    ->boolean(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `boolean()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Customizing the boolean icons
+
+You may customize the [icon](../../styling/icons) representing each state:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+use Filament\Support\Icons\Heroicon;
+
+IconColumn::make('is_featured')
+    ->boolean()
+    ->trueIcon(Heroicon::OutlinedCheckBadge)
+    ->falseIcon(Heroicon::OutlinedXMark)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `trueIcon()` and `falseIcon()` methods also accept functions to dynamically calculate them. You can inject various utilities into the functions as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/icon/boolean-icon" alt="Icon column to display a boolean with custom icons" version="4.x" />
+
+### Customizing the boolean colors
+
+You may customize the icon [color](../../styling/colors) representing each state:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('is_featured')
+    ->boolean()
+    ->trueColor('info')
+    ->falseColor('warning')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `trueColor()` and `falseColor()` methods also accept functions to dynamically calculate them. You can inject various utilities into the functions as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/icon/boolean-color" alt="Icon column to display a boolean with custom colors" version="4.x" />
+
+## Wrapping multiple icons
+
+When displaying multiple icons, they can be set to wrap if they can't fit on one line, using `wrap()`:
+
+```php
+use Filament\Tables\Columns\IconColumn;
+
+IconColumn::make('icon')
+    ->wrap()
+```
+
+<Aside variant="tip">
+    The "width" for wrapping is affected by the column label, so you may need to use a shorter or hidden label to wrap more tightly.
+</Aside>

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/04-image.md

@@ -0,0 +1,308 @@
+---
+title: Image column
+---
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import Aside from "@components/Aside.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+Tables can render images, based on the path in the state of the column:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('avatar')
+```
+
+In this case, the `header_image` state could contain `posts/header-images/4281246003439.jpg`, which is relative to the root directory of the storage disk. The storage disk is defined in the [configuration file](../../introduction/installation#publishing-configuration), `local` by default. You can also set the `FILESYSTEM_DISK` environment variable to change this.
+
+Alternatively, the state could contain an absolute URL to an image, such as `https://example.com/images/header.jpg`.
+
+<AutoScreenshot name="tables/columns/image/simple" alt="Image column" version="4.x" />
+
+## Managing the image disk
+
+The default storage disk is defined in the [configuration file](../../introduction/installation#publishing-configuration), `local` by default. You can also set the `FILESYSTEM_DISK` environment variable to change this. If you want to deviate from the default disk, you may pass a custom disk name to the `disk()` method:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('header_image')
+    ->disk('s3')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `disk()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Public images
+
+By default, Filament will generate temporary URLs to images in the filesystem, unless the [disk](#managing-the-image-disk) is set to `public`. If your images are stored in a public disk, you can set the `visibility()` to `public`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('header_image')
+    ->visibility('public')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `visibility()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Customizing the size
+
+You may customize the image size by passing a `imageWidth()` and `imageHeight()`, or both with `imageSize()`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('header_image')
+    ->imageWidth(200)
+
+ImageColumn::make('header_image')
+    ->imageHeight(50)
+
+ImageColumn::make('avatar')
+    ->imageSize(40)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static values, the `imageWidth()`, `imageHeight()` and `imageSize()` methods also accept functions to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Square images
+
+You may display the image using a 1:1 aspect ratio:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('avatar')
+    ->imageHeight(40)
+    ->square()
+```
+
+<AutoScreenshot name="tables/columns/image/square" alt="Square image column" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the image should be square or not:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('avatar')
+    ->imageHeight(40)
+    ->square(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `square()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Circular images
+
+You may make the image fully rounded, which is useful for rendering avatars:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('avatar')
+    ->imageHeight(40)
+    ->circular()
+```
+
+<AutoScreenshot name="tables/columns/image/circular" alt="Circular image column" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the image should be circular or not:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('avatar')
+    ->imageHeight(40)
+    ->circular(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `circular()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Adding a default image URL
+
+You can display a placeholder image if one doesn't exist yet, by passing a URL to the `defaultImageUrl()` method:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('header_image')
+    ->defaultImageUrl(url('storage/posts/header-images/default.jpg'))
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `defaultImageUrl()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Stacking images
+
+You may display multiple images as a stack of overlapping images by using `stacked()`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+```
+
+<AutoScreenshot name="tables/columns/image/stacked" alt="Stacked image column" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the images should be stacked or not:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `stacked()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Customizing the stacked ring width
+
+The default ring width is `3`, but you may customize it to be from `0` to `8`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->ring(5)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `ring()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Customizing the stacked overlap
+
+The default overlap is `4`, but you may customize it to be from `0` to `8`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->overlap(2)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `overlap()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Setting a limit
+
+You may limit the maximum number of images you want to display by passing `limit()`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->limit(3)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `limit()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+<AutoScreenshot name="tables/columns/image/limited" alt="Limited image column" version="4.x" />
+
+### Showing the remaining images count
+
+When you set a limit you may also display the count of remaining images by passing `limitedRemainingText()`.
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->limit(3)
+    ->limitedRemainingText()
+```
+
+<AutoScreenshot name="tables/columns/image/limited-remaining-text" alt="Limited image column with remaining text" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the remaining text should be displayed or not:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->limit(3)
+    ->limitedRemainingText(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `limitedRemainingText()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Customizing the limited remaining text size
+
+By default, the size of the remaining text is `TextSize::Small`. You can customize this to be `TextSize::ExtraSmall`, `TextSize::Medium` or `TextSize::Large` using the `size` parameter:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+use Filament\Support\Enums\TextSize;
+
+ImageColumn::make('colleagues.avatar')
+    ->imageHeight(40)
+    ->circular()
+    ->stacked()
+    ->limit(3)
+    ->limitedRemainingText(size: TextSize::Large)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `limitedRemainingText()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Prevent file existence checks
+
+When the schema is loaded, it will automatically detect whether the images exist to prevent errors for missing files. This is all done on the backend. When using remote storage with many images, this can be time-consuming. You can use the `checkFileExistence(false)` method to disable this feature:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('attachment')
+    ->checkFileExistence(false)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `checkFileExistence()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Wrapping multiple images
+
+Images can be set to wrap if they can't fit on one line, by setting `wrap()`:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('colleagues.avatar')
+    ->circular()
+    ->stacked()
+    ->wrap()
+```
+
+<Aside variant="tip">
+    The "width" for wrapping is affected by the column label, so you may need to use a shorter or hidden label to wrap more tightly.
+</Aside>
+
+## Adding extra HTML attributes to the image
+
+You can pass extra HTML attributes to the `<img>` element via the `extraImgAttributes()` method. The attributes should be represented by an array, where the key is the attribute name and the value is the attribute value:
+
+```php
+use Filament\Tables\Columns\ImageColumn;
+
+ImageColumn::make('logo')
+    ->extraImgAttributes([
+        'alt' => 'Logo',
+        'loading' => 'lazy',
+    ])
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `extraImgAttributes()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+By default, calling `extraImgAttributes()` multiple times will overwrite the previous attributes. If you wish to merge the attributes instead, you can pass `merge: true` to the method.

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/05-color.md

@@ -0,0 +1,59 @@
+---
+title: Color column
+---
+import Aside from "@components/Aside.astro"
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+The color column allows you to show the color preview from a CSS color definition, typically entered using the [color picker field](../../forms/color-picker), in one of the supported formats (HEX, HSL, RGB, RGBA).
+
+```php
+use Filament\Tables\Columns\ColorColumn;
+
+ColorColumn::make('color')
+```
+
+<AutoScreenshot name="tables/columns/color/simple" alt="Color column" version="4.x" />
+
+## Allowing the color to be copied to the clipboard
+
+You may make the color copyable, such that clicking on the preview copies the CSS value to the clipboard, and optionally specify a custom confirmation message and duration in milliseconds. This feature only works when SSL is enabled for the app.
+
+```php
+use Filament\Tables\Columns\ColorColumn;
+
+ColorColumn::make('color')
+    ->copyable()
+    ->copyMessage('Copied!')
+    ->copyMessageDuration(1500)
+```
+
+<AutoScreenshot name="tables/columns/color/copyable" alt="Color column with a button to copy it" version="4.x" />
+
+Optionally, you may pass a boolean value to control if the text should be copyable or not:
+
+```php
+use Filament\Tables\Columns\ColorColumn;
+
+ColorColumn::make('color')
+    ->copyable(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `copyable()`, `copyMessage()`, and `copyMessageDuration()` methods also accept functions to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Wrapping multiple color blocks
+
+Color blocks can be set to wrap if they can't fit on one line, by setting `wrap()`:
+
+```php
+use Filament\Tables\Columns\ColorColumn;
+
+ColorColumn::make('color')
+    ->wrap()
+```
+
+<Aside variant="tip">
+    The "width" for wrapping is affected by the column label, so you may need to use a shorter or hidden label to wrap more tightly.
+</Aside>

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/06-select.md

@@ -0,0 +1,466 @@
+---
+title: Select column
+---
+import Aside from "@components/Aside.astro"
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+The select column allows you to render a select field inside the table, which can be used to update that database record without needing to open a new page or a modal.
+
+You must pass options to the column:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('status')
+    ->options([
+        'draft' => 'Draft',
+        'reviewing' => 'Reviewing',
+        'published' => 'Published',
+    ])
+```
+
+<AutoScreenshot name="tables/columns/select/simple" alt="Select column" version="4.x" />
+
+## Enabling the JavaScript select
+
+By default, Filament uses the native HTML5 select. You may enable a more customizable JavaScript select using the `native(false)` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('status')
+    ->options([
+        'draft' => 'Draft',
+        'reviewing' => 'Reviewing',
+        'published' => 'Published',
+    ])
+    ->native(false)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `native()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Searching options
+
+You may enable a search input to allow easier access to many options, using the `searchableOptions()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->label('Author')
+    ->options(User::query()->pluck('name', 'id'))
+    ->searchableOptions()
+```
+
+Optionally, you may pass a boolean value to control if the input should be searchable or not:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->label('Author')
+    ->options(User::query()->pluck('name', 'id'))
+    ->searchableOptions(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `searchableOptions()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Returning custom search results
+
+If you have lots of options and want to populate them based on a database search or other external data source, you can use the `getOptionsSearchResultsUsing()` and `getOptionLabelUsing()` methods instead of `options()`.
+
+The `getOptionsSearchResultsUsing()` method accepts a callback that returns search results in `$key => $value` format. The current user's search is available as `$search`, and you should use that to filter your results.
+
+The `getOptionLabelUsing()` method accepts a callback that transforms the selected option `$value` into a label. This is used when the form is first loaded when the user has not made a search yet. Otherwise, the label used to display the currently selected option would not be available.
+
+Both `getOptionsSearchResultsUsing()` and `getOptionLabelUsing()` must be used on the select if you want to provide custom search results:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->searchableOptions()
+    ->getOptionsSearchResultsUsing(fn (string $search): array => User::query()
+        ->where('name', 'like', "%{$search}%")
+        ->limit(50)
+        ->pluck('name', 'id')
+        ->all())
+    ->getOptionLabelUsing(fn ($value): ?string => User::find($value)?->name),
+```
+
+`getOptionLabelUsing()` is crucial, since it provides Filament with the label of the selected option, so it doesn't need to execute a full search to find it. If an option is not valid, it should return `null`.
+
+<UtilityInjection set="tableColumns" version="4.x" extras="Option value;;mixed;;$value;;The option value to retrieve the label for.||Search;;?string;;$search;;[<code>getOptionsSearchResultsUsing()</code> only] The current search input value, if the field is searchable.">You can inject various utilities into these functions as parameters.</UtilityInjection>
+
+### Setting a custom loading message
+
+When you're using a searchable select or multi-select, you may want to display a custom message while the options are loading. You can do this using the `optionsLoadingMessage()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->optionsLoadingMessage('Loading authors...')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `optionsLoadingMessage()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Setting a custom no search results message
+
+When you're using a searchable select or multi-select, you may want to display a custom message when no search results are found. You can do this using the `noOptionsSearchResultsMessage()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->noOptionsSearchResultsMessage('No authors found.')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `noOptionsSearchResultsMessage()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Setting a custom search prompt
+
+When you're using a searchable select or multi-select, you may want to display a custom message when the user has not yet entered a search term. You can do this using the `optionsSearchPrompt()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions(['name', 'email'])
+    ->optionsSearchPrompt('Search authors by their name or email address')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `optionsSearchPrompt()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Setting a custom searching message
+
+When you're using a searchable select or multi-select, you may want to display a custom message while the search results are being loaded. You can do this using the `optionsSearchingMessage()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->optionsSearchingMessage('Searching authors...')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `optionsSearchingMessage()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Tweaking the search debounce
+
+By default, Filament will wait 1000 milliseconds (1 second) before searching for options when the user types in a searchable select or multi-select. It will also wait 1000 milliseconds between searches, if the user is continuously typing into the search input. You can change this using the `optionsSearchDebounce()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->optionsSearchDebounce(500)
+```
+
+Ensure that you are not lowering the debounce too much, as this may cause the select to become slow and unresponsive due to a high number of network requests to retrieve options from server.
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `optionsSearchDebounce()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Integrating with an Eloquent relationship
+
+You may employ the `optionsRelationship()` method of the `SelectColumn` to configure a `BelongsTo` relationship to automatically retrieve options from. The `titleAttribute` is the name of a column that will be used to generate a label for each option:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+```
+
+### Searching relationship options across multiple columns
+
+By default, if the select is also searchable, Filament will return search results for the relationship based on the title column of the relationship. If you'd like to search across multiple columns, you can pass an array of columns to the `searchableOptions()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions(['name', 'email'])
+```
+
+### Preloading relationship options
+
+If you'd like to populate the searchable options from the database when the page is loaded, instead of when the user searches, you can use the `preloadOptions()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->preloadOptions()
+```
+
+Optionally, you may pass a boolean value to control if the input should be preloaded or not:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->preload(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `preload()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Excluding the current record
+
+When working with recursive relationships, you will likely want to remove the current record from the set of results.
+
+This can be easily be done using the `ignoreRecord` argument:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('parent_id')
+    ->optionsRelationship(name: 'parent', titleAttribute: 'name', ignoreRecord: true)
+```
+
+### Customizing the relationship query
+
+You may customize the database query that retrieves options using the third parameter of the `optionsRelationship()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+use Illuminate\Database\Eloquent\Builder;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(
+        name: 'author',
+        titleAttribute: 'name',
+        modifyQueryUsing: fn (Builder $query) => $query->withTrashed(),
+    )
+```
+
+<UtilityInjection set="tableColumns" version="4.x" extras="Query;;Illuminate\Database\Eloquent\Builder;;$query;;The Eloquent query builder to modify.||Search;;?string;;$search;;The current search input value, if the field is searchable.">The `modifyQueryUsing` argument can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Customizing the relationship option labels
+
+If you'd like to customize the label of each option, maybe to be more descriptive, or to concatenate a first and last name, you could use a virtual column in your database migration:
+
+```php
+$table->string('full_name')->virtualAs('concat(first_name, \' \', last_name)');
+```
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'full_name')
+```
+
+Alternatively, you can use the `getOptionLabelFromRecordUsing()` method to transform an option's Eloquent model into a label:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(
+        name: 'author',
+        modifyQueryUsing: fn (Builder $query) => $query->orderBy('first_name')->orderBy('last_name'),
+    )
+    ->getOptionLabelFromRecordUsing(fn (Model $record) => "{$record->first_name} {$record->last_name}")
+    ->searchableOptions(['first_name', 'last_name'])
+```
+
+<UtilityInjection set="tableColumns" version="4.x" extras="Eloquent record;;Illuminate\Database\Eloquent\Model;;$record;;The Eloquent record to get the option label for.">The `getOptionLabelFromRecordUsing()` method can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Remembering options
+
+By default, when using `optionsRelationship()`, Filament will remember the options for the duration of the table page to improve performance. This means that the options function will only run once per table page instead of once per cell. You can disable this behavior using the `rememberOptions(false)` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->rememberOptions(false)
+```
+
+<Aside variant="warning">
+    When options are remembered, any record-specific options or disabled options will not work correctly, as the same options will be used for all records in the table. If you need record-specific options or disabled options, you should disable option remembering.
+</Aside>
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `rememberOptions()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Allowing HTML in the option labels
+
+By default, Filament will escape any HTML in the option labels. If you'd like to allow HTML, you can use the `allowOptionsHtml()` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('technology')
+    ->options([
+        'tailwind' => '<span class="text-blue-500">Tailwind</span>',
+        'alpine' => '<span class="text-green-500">Alpine</span>',
+        'laravel' => '<span class="text-red-500">Laravel</span>',
+        'livewire' => '<span class="text-pink-500">Livewire</span>',
+    ])
+    ->searchableOptions()
+    ->allowOptionsHtml()
+```
+
+<Aside variant="danger">
+    Be aware that you will need to ensure that the HTML is safe to render, otherwise your application will be vulnerable to XSS attacks.
+</Aside>
+
+Optionally, you may pass a boolean value to control if the input should allow HTML or not:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('technology')
+    ->options([
+        'tailwind' => '<span class="text-blue-500">Tailwind</span>',
+        'alpine' => '<span class="text-green-500">Alpine</span>',
+        'laravel' => '<span class="text-red-500">Laravel</span>',
+        'livewire' => '<span class="text-pink-500">Livewire</span>',
+    ])
+    ->searchableOptions()
+    ->allowOptionsHtml(FeatureFlag::active())
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `allowOptionsHtml()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Wrap or truncate option labels
+
+When using the JavaScript select, labels that exceed the width of the select element will wrap onto multiple lines by default. Alternatively, you may choose to truncate overflowing labels.
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('truncate')
+    ->wrapOptionLabels(false)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `wrapOptionLabels()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Disable placeholder selection
+
+You can prevent the placeholder (null option) from being selected using the `selectablePlaceholder(false)` method:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('status')
+    ->options([
+        'draft' => 'Draft',
+        'reviewing' => 'Reviewing',
+        'published' => 'Published',
+    ])
+    ->selectablePlaceholder(false)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `selectablePlaceholder()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Disabling specific options
+
+You can disable specific options using the `disableOptionWhen()` method. It accepts a closure, in which you can check if the option with a specific `$value` should be disabled:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('status')
+    ->options([
+        'draft' => 'Draft',
+        'reviewing' => 'Reviewing',
+        'published' => 'Published',
+    ])
+    ->default('draft')
+    ->disableOptionWhen(fn (string $value): bool => $value === 'published')
+```
+
+<UtilityInjection set="tableColumns" version="4.x" extras="Option value;;mixed;;$value;;The value of the option to disable.||Option label;;string | Illuminate\Contracts\Support\Htmlable;;$label;;The label of the option to disable.">You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Limiting the number of options
+
+You can limit the number of options that are displayed in a searchable select or multi-select using the `optionsLimit()` method. The default is 50:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->optionsRelationship(name: 'author', titleAttribute: 'name')
+    ->searchableOptions()
+    ->optionsLimit(20)
+```
+
+Ensure that you are not raising the limit too high, as this may cause the select to become slow and unresponsive due to high in-browser memory usage.
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing a static value, the `optionsLimit()` method also accepts a function to dynamically calculate it. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+## Validation
+
+You can validate the input by passing any [Laravel validation rules](https://laravel.com/docs/validation#available-validation-rules) in an array:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('status')
+    ->options([
+        'draft' => 'Draft',
+        'reviewing' => 'Reviewing',
+        'published' => 'Published',
+    ])
+    ->rules(['required'])
+```
+
+### Valid options validation (`in` rule)
+
+The `in` rule ensures that users cannot select an option that is not in the list of options. This is an important rule for data integrity purposes, so Filament applies it by default to all select fields.
+
+Since there are many ways for a select field to populate its options, and in many cases the options are not all loaded into the select by default and require searching to retrieve them, Filament uses the presence of a valid "option label" to determine whether the selected value exists. It also checks if that option is [disabled](#disabling-specific-options) or not.
+
+If you are using a custom search query to retrieve options, you should ensure that the `getOptionLabelUsing()` method is defined, so that Filament can validate the selected value against the available options:
+
+```php
+use Filament\Tables\Columns\SelectColumn;
+
+SelectColumn::make('author_id')
+    ->searchableOptions()
+    ->getOptionsSearchResultsUsing(fn (string $search): array => Author::query()
+        ->where('name', 'like', "%{$search}%")
+        ->limit(50)
+        ->pluck('name', 'id')
+        ->all())
+    ->getOptionLabelUsing(fn (string $value): ?string => Author::find($value)?->name),
+```
+
+The `getOptionLabelUsing()` method should return `null` if the option is not valid, to allow Filament to determine that the selected value is not in the list of options. If the option is valid, it should return the label of the option.
+
+If you are using the `optionsRelationship()` method, the `getOptionLabelUsing()` method will be automatically defined for you, so you don't need to worry about it.
+
+## Lifecycle hooks
+
+Hooks may be used to execute code at various points within the select's lifecycle:
+
+```php
+SelectColumn::make()
+    ->beforeStateUpdated(function ($record, $state) {
+        // Runs before the state is saved to the database.
+    })
+    ->afterStateUpdated(function ($record, $state) {
+        // Runs after the state is saved to the database.
+    })
+```

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/07-toggle.md

@@ -0,0 +1,30 @@
+---
+title: Toggle column
+---
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+
+## Introduction
+
+The toggle column allows you to render a toggle button inside the table, which can be used to update that database record without needing to open a new page or a modal:
+
+```php
+use Filament\Tables\Columns\ToggleColumn;
+
+ToggleColumn::make('is_admin')
+```
+
+<AutoScreenshot name="tables/columns/toggle/simple" alt="Toggle column" version="4.x" />
+
+## Lifecycle hooks
+
+Hooks may be used to execute code at various points within the toggle's lifecycle:
+
+```php
+ToggleColumn::make()
+    ->beforeStateUpdated(function ($record, $state) {
+        // Runs before the state is saved to the database.
+    })
+    ->afterStateUpdated(function ($record, $state) {
+        // Runs after the state is saved to the database.
+    })
+```

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/08-text-input.md

@@ -0,0 +1,96 @@
+---
+title: Text input column
+---
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+import UtilityInjection from "@components/UtilityInjection.astro"
+
+## Introduction
+
+The text input column allows you to render a text input inside the table, which can be used to update that database record without needing to open a new page or a modal:
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+
+TextInputColumn::make('email')
+```
+
+<AutoScreenshot name="tables/columns/text-input/simple" alt="Text input column" version="4.x" />
+
+## Validation
+
+You can validate the input by passing any [Laravel validation rules](https://laravel.com/docs/validation#available-validation-rules) in an array:
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+
+TextInputColumn::make('name')
+    ->rules(['required', 'max:255'])
+```
+
+## Customizing the HTML input type
+
+You may use the `type()` method to pass a custom [HTML input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#input_types):
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+
+TextInputColumn::make('background_color')->type('color')
+```
+
+## Lifecycle hooks
+
+Hooks may be used to execute code at various points within the input's lifecycle:
+
+```php
+TextInputColumn::make()
+    ->beforeStateUpdated(function ($record, $state) {
+        // Runs before the state is saved to the database.
+    })
+    ->afterStateUpdated(function ($record, $state) {
+        // Runs after the state is saved to the database.
+    })
+```
+
+## Adding affix text aside the field
+
+You may place text before and after the input using the `prefix()` and `suffix()` methods:
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+
+TextInputColumn::make('domain')
+    ->prefix('https://')
+    ->suffix('.com')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `prefix()` and `suffix()` methods also accept a function to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+### Using icons as affixes
+
+You may place an [icon](../../../../docs/08-styling/04-icons) before and after the input using the `prefixIcon()` and `suffixIcon()` methods:
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+use Filament\Support\Icons\Heroicon;
+
+TextInputColumn::make('domain')
+    ->prefixIcon(Heroicon::GlobeAlt)
+    ->suffixIcon(Heroicon::CheckCircle)
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `prefixIcon()` and `suffixIcon()` methods also accept a function to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>
+
+#### Setting the affix icon's color
+
+Affix icons are gray by default, but you may set a different color using the `prefixIconColor()` and `suffixIconColor()` methods:
+
+```php
+use Filament\Tables\Columns\TextInputColumn;
+use Filament\Support\Icons\Heroicon;
+
+TextInputColumn::make('status')
+    ->suffixIcon(Heroicon::CheckCircle)
+    ->suffixIconColor('success')
+```
+
+<UtilityInjection set="tableColumns" version="4.x">As well as allowing static values, the `prefixIconColor()` and `suffixIconColor()` methods also accept a function to dynamically calculate them. You can inject various utilities into the function as parameters.</UtilityInjection>

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/09-checkbox.md

@@ -0,0 +1,30 @@
+---
+title: Checkbox column
+---
+import AutoScreenshot from "@components/AutoScreenshot.astro"
+
+## Introduction
+
+The checkbox column allows you to render a checkbox inside the table, which can be used to update that database record without needing to open a new page or a modal:
+
+```php
+use Filament\Tables\Columns\CheckboxColumn;
+
+CheckboxColumn::make('is_admin')
+```
+
+<AutoScreenshot name="tables/columns/checkbox/simple" alt="Checkbox column" version="4.x" />
+
+## Lifecycle hooks
+
+Hooks may be used to execute code at various points within the checkbox's lifecycle:
+
+```php
+CheckboxColumn::make()
+    ->beforeStateUpdated(function ($record, $state) {
+        // Runs before the state is saved to the database.
+    })
+    ->afterStateUpdated(function ($record, $state) {
+        // Runs after the state is saved to the database.
+    })
+```

Optimized Atomcms daily updated/vendor/filament/tables/docs/02-columns/10-custom-columns.md

@@ -0,0 +1,162 @@
+---
+title: Custom columns
+---
+import Aside from "@components/Aside.astro"
+
+## Introduction
+
+You may create your own custom column classes and views, which you can reuse across your project, and even release as a plugin to the community.
+
+To create a custom column class and view, you may use the following command:
+
+```bash
+php artisan make:filament-table-column AudioPlayerColumn
+```
+
+This will create the following component class:
+
+```php
+use Filament\Tables\Columns\Column;
+
+class AudioPlayerColumn extends Column
+{
+    protected string $view = 'filament.tables.columns.audio-player-column';
+}
+```
+
+It will also create a view file at `resources/views/filament/tables/columns/audio-player-column.blade.php`.
+
+<Aside variant="info">
+    Filament table columns are **not** Livewire components. Defining public properties and methods on a table column class will not make them accessible in the Blade view.
+</Aside>
+
+## Accessing the state of the column in the Blade view
+
+Inside the Blade view, you may access the [state](overview#column-content-state) of the column using the `$getState()` function:
+
+```blade
+<div>
+    {{ $getState() }}
+</div>
+```
+
+## Accessing the Eloquent record in the Blade view
+
+Inside the Blade view, you may access the current table row's Eloquent record using the `$record` variable:
+
+```blade
+<div>
+    {{ $record->name }}
+</div>
+```
+
+## Accessing the current Livewire component instance in the Blade view
+
+Inside the Blade view, you may access the current Livewire component instance using `$this`:
+
+```blade
+@php
+    use Filament\Resources\Users\RelationManagers\ConferencesRelationManager;
+@endphp
+
+<div>
+    @if ($this instanceof ConferencesRelationManager)
+        You are editing the conferences of a user.
+    @endif
+</div>
+```
+
+## Accessing the current column instance in the Blade view
+
+Inside the Blade view, you may access the current column instance using `$column`. You can call public methods on this object to access other information that may not be available in variables:
+
+```blade
+<div>
+    @if ($column->isLabelHidden())
+        This is a new conference.
+    @endif
+</div>
+```
+
+## Adding a configuration method to a custom column class
+
+You may add a public method to the custom column class that accepts a configuration value, stores it in a protected property, and returns it again from another public method:
+
+```php
+use Filament\Tables\Columns\Column;
+
+class AudioPlayerColumn extends Column
+{
+    protected string $view = 'filament.tables.columns.audio-player-column';
+    
+    protected ?float $speed = null;
+
+    public function speed(?float $speed): static
+    {
+        $this->speed = $speed;
+
+        return $this;
+    }
+
+    public function getSpeed(): ?float
+    {
+        return $this->speed;
+    }
+}
+```
+
+Now, in the Blade view for the custom column, you may access the speed using the `$getSpeed()` function:
+
+```blade
+<div>
+    {{ $getSpeed() }}
+</div>
+```
+
+Any public method that you define on the custom column class can be accessed in the Blade view as a variable function in this way.
+
+To pass the configuration value to the custom column class, you may use the public method:
+
+```php
+use App\Filament\Tables\Columns\AudioPlayerColumn;
+
+AudioPlayerColumn::make('recording')
+    ->speed(0.5)
+```
+
+## Allowing utility injection in a custom column configuration method
+
+[Utility injection](overview#column-utility-injection) is a powerful feature of Filament that allows users to configure a component using functions that can access various utilities. You can allow utility injection by ensuring that the parameter type and property type of the configuration allows the user to pass a `Closure`. In the getter method, you should pass the configuration value to the `$this->evaluate()` method, which will inject utilities into the user's function if they pass one, or return the value if it is static:
+
+```php
+use Closure;
+use Filament\Tables\Columns\Column;
+
+class AudioPlayerColumn extends Column
+{
+    protected string $view = 'filament.tables.columns.audio-player-column';
+    
+    protected float | Closure | null $speed = null;
+
+    public function speed(float | Closure | null $speed): static
+    {
+        $this->speed = $speed;
+
+        return $this;
+    }
+
+    public function getSpeed(): ?float
+    {
+        return $this->evaluate($this->speed);
+    }
+}
+```
+
+Now, you can pass a static value or a function to the `speed()` method, and [inject any utility](overview#component-utility-injection) as a parameter:
+
+```php
+use App\Filament\Tables\Columns\AudioPlayerColumn;
+
+AudioPlayerColumn::make('recording')
+    ->speed(fn (Conference $record): float => $record->isGlobal() ? 1 : 0.5)
+```