Laravel Canonical URLs

https://github.com/fkrzski/laravel-canonical
Admin
A lightweight Laravel package for generating canonical URLs to prevent duplicate content issues and...
Tokens:33,313
Snippets:332
Trust Score:5.4
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install development dependencies

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Run this command to install the package's development dependencies before running the test suite.

```bash
composer install
```

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

### Usage examples for <x-canonical>

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Usage examples for the component: using the current request URL, specifying a static path, and using a dynamic path.

```blade
<head>
    {{-- Use current request URL --}}
    <x-canonical />

    {{-- Specify custom path --}}
    <x-canonical path="/products/item" />

    {{-- Use dynamic path --}}
    <x-canonical :path="$post->canonical_path" />
</head>
```

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

### Canonical facade generate() usage examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Usage examples for the Canonical facade. With no argument it canonicalises the current request URI including query string; with a path it joins it onto the configured canonical domain. The comments show expected outputs.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

Canonical::generate();                 // current request
Canonical::generate('/products/item'); // https://example.com/products/item
Canonical::generate('/');              // https://example.com
```

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

### Basic usage example

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalConfig.md

Resolves CanonicalConfig from the container and calls its accessors. Assumes CANONICAL_DOMAIN is set to https://example.com.

```php
use Fkrzski\LaravelCanonical\Contracts\CanonicalConfigInterface;

// .env: CANONICAL_DOMAIN=https://example.com
$config = app(CanonicalConfigInterface::class);

$config->getBaseUrl();               // "https://example.com"
$config->shouldTrimTrailingSlash();  // true (default)
```

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

### Typed parameter usage with CanonicalConfigInterface

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/Contracts.md

Shows how to type-hint a contract in a constructor to let the container inject the singleton. The example uses CanonicalConfigInterface to get the base URL.

```php
use Fkrzski\LaravelCanonical\Contracts\CanonicalConfigInterface;

final class SeoMetaService
{
    public function __construct(
        private CanonicalConfigInterface $config
    ) {}

    public function canonicalDomain(): string
    {
        return $this->config->getBaseUrl();
    }
}
```

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

### Error handling example

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/BaseUrlValidator.md

Shows how to catch CanonicalConfigurationException when validating an invalid domain like ftp://example.com.

```php
use Fkrzski\LaravelCanonical\Validation\BaseUrlValidator;
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

$validator = new BaseUrlValidator();

try {
    $validator->validate('ftp://example.com');
} catch (CanonicalConfigurationException $e) {
    // "Invalid URL scheme for 'ftp://example.com'. Only 'http' and 'https' schemes are allowed."
}
```

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

### Basic usage example

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/BaseUrlValidator.md

Shows how to instantiate BaseUrlValidator and validate valid domains, including ports, subdomains, and http.

```php
use Fkrzski\LaravelCanonical\Validation\BaseUrlValidator;

$validator = new BaseUrlValidator();

$validator->validate('https://example.com');       // ok
$validator->validate('https://example.com:8000');  // ok (port allowed)
$validator->validate('https://www.example.com');   // ok (subdomain allowed)
$validator->validate('http://localhost');          // ok (http allowed)
```

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

### canonical() helper usage examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Usage examples for the canonical() helper. With a path it returns the URL string; without arguments it returns the generator for fluent use. The return type is conditional so PHPStan resolves each call site to one concrete type.

```php
$url       = canonical('/products/item'); // "https://example.com/products/item"
$generator = canonical();                 // fluent generator
$url       = canonical()->generate('/products/item');
```

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

### Path normalisation examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/guide.mdx

Shows how paths are normalised: leading slash optional, trailing slash trimmed, root collapses to bare domain, query parameters preserved.

```php
// Domain: https://example.com
Canonical::generate('/blog/');         // https://example.com/blog
Canonical::generate('blog');           // https://example.com/blog
Canonical::generate('/');              // https://example.com
Canonical::generate('/blog/post/123'); // https://example.com/blog/post/123
```

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

### generate() implementation

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Implementation of generate() that resolves the path, gets the base URL, and delegates to the builder.

```php
public function generate(?string $path = null): string
{
    $uri = $path ?? $this->resolveCurrentPath();
    $baseUrl = $this->config->getBaseUrl();

    return $this->builder->build($baseUrl, $uri);
}
```

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

### Output for <x-canonical path="/products/item" />

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Example output for <x-canonical path="/products/item" />, showing the generated canonical link tag.

```html
<link rel="canonical" href="https://example.com/products/item" />
```

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

### Install laravel-canonical via Composer

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/index.mdx

Requires the package. The service provider and facade are auto-discovered.

```bash
composer require fkrzski/laravel-canonical
```

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

### Basic usage from PHP

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalFacade.md

Use the facade to generate canonical URLs for the current request or a given path. The examples show the expected output for different inputs.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

$url = Canonical::generate();                 // current request -> "https://example.com/blog/post"
$url = Canonical::generate('/products/item'); // "https://example.com/products/item"
$url = Canonical::generate('/');              // "https://example.com"
```

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

### Set canonical domain in PHPUnit setUp

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Configure the canonical.domain to a known host in a PHPUnit setUp method. This is required before asserting on generated URLs.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

protected function setUp(): void
{
    parent::setUp();

    config(['canonical.domain' => 'https://example.com']);
}
```

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

### x-canonical component usage examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Usage examples for the x-canonical Blade component. It renders an HTML-escaped <link rel="canonical" href="…" /> tag. The path attribute is optional; null, '', and '/' fall back to the bare domain. Throws CanonicalConfigurationException.

```blade
<x-canonical />
<x-canonical path="/products/item" />
<x-canonical :path="$post->canonical_path" />
```

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

### Invalid canonical domain examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

These domain values throw CanonicalConfigurationException: no scheme, unsupported scheme, or empty value.

```dotenv
CANONICAL_DOMAIN=example.com
CANONICAL_DOMAIN=ftp://example.com
CANONICAL_DOMAIN=
```

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

### Error handling with CanonicalConfigurationException

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Error handling example showing how a misconfigured domain throws CanonicalConfigurationException when the generator is first pulled from the container.

```php
use Fkrzski\LaravelCanonical\Contracts\CanonicalUrlGeneratorInterface;
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

try {
    $url = app(CanonicalUrlGeneratorInterface::class)->generate('/page');
} catch (CanonicalConfigurationException $e) {
    // e.g. CANONICAL_DOMAIN unset, ftp:// scheme, or missing host
    report($e->getMessage());
}
```

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

### Resolve generator directly from container

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Example of resolving the generator directly from the container instead of using the facade. It calls generate() with a path to produce a URL.

```php
$url = app(CanonicalUrlGeneratorInterface::class)->generate('/products/item');
```

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

### Emit canonical tag with canonical() helper

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/blade.mdx

Use the canonical() helper to get the URL string and write the tag yourself. This allows the same URL to appear in more than one place, such as in an og:url meta tag. The helper returns the generator when called without arguments, so you must call ->generate() to get the URL.

```blade
<head>
    <link rel="canonical" href="{{ canonical('/products/item') }}" />
    <link rel="canonical" href="{{ canonical()->generate() }}" />
    <meta property="og:url" content="{{ canonical()->generate() }}" />
</head>
```

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

### canonical() full docblock declaration

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalHelperFunction.md

The complete PHPDoc block from the source, describing parameters, return types, and usage examples.

```php
/**
 * Get canonical URL generator instance or generate canonical URL.
 *
 * When called without arguments, returns the generator instance for fluent usage.
 * When called with a path, returns the canonical URL string.
 *
 * @param  string|null  $path  Optional path to generate canonical URL for
 * @return ($path is null ? CanonicalUrlGeneratorInterface : string)
 *
 * @example
 * // Get generator instance
 * canonical()->generate('/path');
 *
 * // Generate URL directly
 * canonical('/path'); // "https://example.com/path"
 */
```

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

### @canonical directive usage examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Usage examples for the @canonical Blade directive. It echoes the same tag as the component, escaping the URL with e(). The optional expression is a path string or variable.

```blade
@canonical
@canonical('/products/item')
@canonical($canonicalPath)
```

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

### Catching CanonicalConfigurationException around the canonical() helper with message-based error handling

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalConfigurationException.md

Example of catching the exception when using the canonical() helper and distinguishing the failure mode by examining the exception message. It checks for specific message strings to identify missing domain, wrong scheme, or other URL errors.

```php
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

try {
    canonical('/page');
} catch (CanonicalConfigurationException $e) {
    $message = $e->getMessage();

    if ($message === 'Canonical domain is not set in config.') {
        // Missing CANONICAL_DOMAIN / APP_URL entirely
    } elseif (str_contains($message, 'Only \'http\' and \'https\'')) {
        // Wrong scheme configured
    } else {
        // Invalid URL format or missing host
    }
}
```

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

### Catching CanonicalConfigurationException around the Canonical facade

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalConfigurationException.md

Example of catching the exception when using the Canonical::generate() facade method. The failure is isolated to configuration, and the caught exception's message is reported.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

try {
    $url = Canonical::generate('/products/item');
} catch (CanonicalConfigurationException $e) {
    // Failure is isolated to configuration; $url has no usable value.
    report('Canonical URL could not be generated: '.$e->getMessage());
}
```

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

### Valid canonical domain examples

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

These domain values are valid. A trailing slash on the domain is stripped before validation, so the third form behaves like the first.

```dotenv
CANONICAL_DOMAIN=https://example.com
CANONICAL_DOMAIN=http://localhost:8000
CANONICAL_DOMAIN=https://example.com/
```

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

### Rebind container contract in AppServiceProvider

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Example of rebinding a container contract to a custom implementation in app/Providers/AppServiceProvider.php. The deferred provider binds contracts as singletons; rebind any of them to swap in your own implementation.

```php
$this->app->singleton(CanonicalUrlBuilderInterface::class, MyUrlBuilder::class);
```

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

### canonical() with no argument is not a string

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/blade.mdx

Without arguments, the canonical() helper returns the generator, not a URL, so echoing it directly throws an error. Finish the call with ->generate() to get the URL string.

```blade
<link rel="canonical" href="{{ canonical() }}" />             {{-- ✗ --}}
<link rel="canonical" href="{{ canonical()->generate() }}" /> {{-- ✓ --}}
```

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

### Customized canonical view with $canonicalUrl callable

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/blade.mdx

The published view receives a $canonicalUrl callable, so a customized tag keeps the same generation logic. This example shows a custom view that adds an alternate hreflang link.

```blade
<link rel="canonical" href="{{ $canonicalUrl() }}" />
<link rel="alternate" hreflang="en" href="{{ $canonicalUrl() }}" />
```

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

### boot() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalServiceProvider.md

The boot() method is called by the framework at boot time. It returns void and takes no parameters.

```php
public function boot(): void
```

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

### build() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Method signature for build, accepting baseUrl and path strings.

```php
public function build(string $baseUrl, string $path): string
```

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

### Publish config and views with artisan vendor:publish

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/configuration.md

Run these commands to publish the package's config file and views. Publishing is optional because the provider merges defaults automatically.

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

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

### Run the full quality gate

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Run this command to execute the full quality gate, which includes Pint, Rector, PHPStan, type coverage, and a mutation-tested Pest run.

```bash
composer test
```

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

### Full config file with defaults and comments

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

The complete config file with comments explaining the domain fallback chain and trailing-slash trimming. The domain falls back to APP_URL then http://localhost when CANONICAL_DOMAIN is unset.

```php
return [
    // The domain every canonical URL is built from. Falls back to APP_URL,
    // then http://localhost, when CANONICAL_DOMAIN is unset.
    'domain' => env('CANONICAL_DOMAIN', env('APP_URL', 'http://localhost')),

    // Trim trailing slashes from generated URLs (/blog/ → /blog). @since 1.1.0
    'trim_trailing_slash' => env('CANONICAL_TRIM_TRAILING_SLASH', true),
];
```

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

### build() method implementation

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Full implementation of build() with trailing slash normalization logic.

```php
public function build(string $baseUrl, string $path): string
{
    $baseUrlHadTrailingSlash = str_ends_with($baseUrl, '/');
    $pathHadTrailingSlash = str_ends_with($path, '/');

    $baseUrl = rtrim($baseUrl, '/');
    $path = trim($path, '/');

    if (! $this->config->shouldTrimTrailingSlash() && $pathHadTrailingSlash && $path !== '') {
        $path .= '/';
    }

    if ($path === '') {
        return $this->shouldAddTrailingSlashForEmptyPath($baseUrlHadTrailingSlash, $pathHadTrailingSlash)
            ? $baseUrl.'/'
            : $baseUrl;
    }

    return $baseUrl.'/'.$path;
}
```

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

### Publish the canonical config file

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

Run this artisan command to publish the config file. Publishing is optional; the package runs without it.

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

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

### provides() return array

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalServiceProvider.md

Returns the list of container contracts the provider is responsible for, including BaseUrlValidatorInterface, CanonicalConfigInterface, CanonicalUrlBuilderInterface, and CanonicalUrlGeneratorInterface.

```php
return [
    BaseUrlValidatorInterface::class,
    CanonicalConfigInterface::class,
    CanonicalUrlBuilderInterface::class,
    CanonicalUrlGeneratorInterface::class,
];
```

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

### __construct()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Constructor for the Canonical component. Accepts an optional path attribute.

```APIDOC
## `__construct(?string $path = null)`

### Description
Constructor for the Canonical component. Accepts an optional path attribute.

### Parameters
- **path** (`?string`) - Optional - Path to canonicalize. `null`, `''`, and `'/'` fall back to the bare canonical domain.

### Returns
No explicit return value (constructor).
```

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

### Publish canonical views with artisan command

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/blade.mdx

Publish the package's view to customize the canonical tag. Run this artisan command to copy the view to your application.

```bash
php artisan vendor:publish --tag="canonical-views"
```

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

### CanonicalConfig::__construct()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalConfig.md

Constructor that reads the canonical domain from config, validates it, and stores the base URL and trailing-slash policy. Throws CanonicalConfigurationException if the domain is empty or invalid.

```APIDOC
## CanonicalConfig::__construct()

### Description
Initializes the configuration object by reading the `canonical.domain` config value, stripping trailing slashes, validating the domain, and storing the base URL and trailing-slash trimming flag.

### Method
Constructor

### Signature
```php
public function __construct(
    BaseUrlValidatorInterface $validator
)
```

### Parameters
- **validator** (BaseUrlValidatorInterface) - Required - Validates the domain after trailing slashes are stripped.

### Behavior
1. Reads `config()->string('canonical.domain')` (default chain: `CANONICAL_DOMAIN` → `APP_URL` → `http://localhost`).
2. Throws `CanonicalConfigurationException('Canonical domain is not set in config.')` when the value is empty.
3. Strips all trailing `/` characters from the domain with `trim($domain, '/')`.
4. Delegates validation of the trimmed domain to `$validator->validate($trimmedDomain)`.
5. Stores the trimmed domain in `$this->baseUrl` and `config()->boolean('canonical.trim_trailing_slash')` in `$this->trimTrailingSlash`.

### Throws
- **CanonicalConfigurationException** - When domain is unset/empty, or validator rejection (invalid URL format, non-`http(s)` scheme, missing host).
```

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

### provides() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalServiceProvider.md

Declares the method signature for provides(), which returns an array of interface FQCN strings. Used by the deferred-provider mechanism to know when register() must run.

```php
public function provides(): array
```

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

### Canonical render() implementation

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Implementation of render() returning the view for the 'canonical::components.canonical' view name.

```php
/** @var view-string $viewName */
$viewName = 'canonical::components.canonical';

return view($viewName);
```

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

### canonical() helper

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Called with a path it returns the URL string; called without arguments it returns the generator for fluent use.

```APIDOC
## canonical() helper

### Description
Called with a path it returns the URL string; called without arguments it returns the generator for fluent use.

### Method
PHP function

### Signature
`canonical(?string $path = null): CanonicalUrlGeneratorInterface|string`

### Parameters
- **$path** (?string) - Optional - Path to canonicalise. If null, returns the generator.

### Returns
- **string** - The canonical URL when a path is provided.
- **CanonicalUrlGeneratorInterface** - The generator when no path is provided.

### Exceptions
- **CanonicalConfigurationException** - Thrown when the domain is not set, invalid, or has an invalid scheme.

### Example
```php
$url       = canonical('/products/item'); // "https://example.com/products/item"
$generator = canonical();                 // fluent generator
$url       = canonical()->generate('/products/item');
```
```

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

### Set canonical domain and trailing slash via config file

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

Alternative configuration using the published config file. This is the same as the environment variables but in PHP array format.

```php
return [
    'domain' => 'https://example.com',
    'trim_trailing_slash' => true,
];
```

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

### register() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalServiceProvider.md

Defines the register() method that performs container registrations. It is called by the container during resolution and returns void.

```php
public function register(): void
```

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

### Generate canonical URL with Helper

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/guide.mdx

Use the canonical() helper as a shortcut to the same generator. It resolves the same generator out of the container.

```php
canonical()->generate();     // request /blog/post → https://example.com/blog/post
canonical('/products/item'); // https://example.com/products/item
```

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

### Constructor with dependency injection

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Constructor with promoted private readonly properties for config and builder.

```php
public function __construct(
    private CanonicalConfigInterface $config,
    private CanonicalUrlBuilderInterface $builder
) {}
```

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

### Run only the unit suite

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Run this command to execute only the unit test suite while iterating.

```bash
composer test:unit
```

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

### render()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Returns the view description for the canonical component's Blade template.

```APIDOC
## `render(): View`

### Description
Returns the view description for the `canonical::components.canonical` view.

### Parameters
None.

### Returns
`Illuminate\Contracts\View\View` - The view object for `canonical::components.canonical`; the framework renders it to produce the `<link>` tag.
```

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

### Register provider and alias in Testbench TestCase

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Declare the CanonicalServiceProvider and the 'Canonical' facade alias in your test case because Testbench does not auto-discover providers.

```php
protected function getPackageProviders($app): array
{
    return [CanonicalServiceProvider::class];
}

protected function getPackageAliases($app): array
{
    return ['Canonical' => Canonical::class];
}
```

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

### Canonical render() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Method signature for render(), which returns the view for the component.

```php
public function render(): View
```

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

### Generate from explicit path to drop tracking parameters

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/guide.mdx

Tracking parameters are not stripped; generate from an explicit path to avoid canonicalising to a URL that still contains them.

```php
Canonical::generate('/products/'.$product->slug);
```

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

### Canonical component constructor

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Constructor for the Canonical component. Accepts an optional path attribute; null, empty string, and '/' all fall back to the bare canonical domain.

```php
public function __construct(
    public ?string $path = null
) {}
```

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

### generate() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Method signature for generate() that accepts an optional path.

```php
public function generate(?string $path = null): string
```

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

### CanonicalConfig constructor

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalConfig.md

Constructor that reads the canonical.domain config, throws CanonicalConfigurationException if empty, trims trailing slashes, validates the domain, and stores baseUrl and trimTrailingSlash.

```php
public function __construct(
    BaseUrlValidatorInterface $validator
) {
    $domain = config()->string('canonical.domain');

    if (empty($domain)) {
        throw new CanonicalConfigurationException('Canonical domain is not set in config.');
    }

    $trimmedDomain = trim($domain, '/');

    $validator->validate($trimmedDomain);

    $this->baseUrl = $trimmedDomain;
    $this->trimTrailingSlash = config()->boolean('canonical.trim_trailing_slash');
}
```

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

### Set canonical domain in Pest beforeEach

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Configure the canonical.domain to a known host in a Pest beforeEach hook. This is required before asserting on generated URLs.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

beforeEach(function (): void {
    config(['canonical.domain' => 'https://example.com']);
});
```

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

### Basic usage of CanonicalUrlBuilder

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Constructs a builder with a config that trims trailing slashes. Shows expected outputs for various base URLs and paths.

```php
use Fkrzski\LaravelCanonical\Config\CanonicalConfig;
use Fkrzski\LaravelCanonical\Services\CanonicalUrlBuilder;
use Fkrzski\LaravelCanonical\Validation\BaseUrlValidator;

config(['canonical.domain' => 'https://example.com', 'canonical.trim_trailing_slash' => true]);

$builder = new CanonicalUrlBuilder(new CanonicalConfig(new BaseUrlValidator()));

$builder->build('https://example.com/', '/page');         // "https://example.com/page"
$builder->build('https://example.com', 'page/');          // "https://example.com/page"
$builder->build('https://example.com:8080', '/a/b');      // "https://example.com:8080/a/b"
```

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

### Basic usage of CanonicalUrlGenerator

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Basic usage with explicit path and current request, showing trailing slash trimming and root path handling.

```php
use Fkrzski\LaravelCanonical\CanonicalUrlGenerator;

// With a CanonicalConfig built from config key 'canonical.domain' = 'https://example.com'
// and a CanonicalUrlBuilder sharing the same config:
$generator = new CanonicalUrlGenerator($config, $builder);

$generator->generate('/blog/post');   // "https://example.com/blog/post"
$generator->generate('/blog/post/');  // "https://example.com/blog/post" (trailing slash trimmed by default)
$generator->generate('/');            // "https://example.com"
$generator->generate();               // canonicalizes request()->getRequestUri()
```

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

### validate() method implementation

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/BaseUrlValidator.md

Implementation of validate() that checks URL format, scheme, and host, throwing CanonicalConfigurationException on failure.

```php
public function validate(string $url): void
{
    if (! filter_var($url, FILTER_VALIDATE_URL)) {
        throw new CanonicalConfigurationException(message: "Invalid URL format: '{$url}'. Expected a valid URL.");
    }

    $parsed = parse_url($url);

    if (! isset($parsed['scheme']) || ! in_array($parsed['scheme'], ['http', 'https'], true)) {
        throw new CanonicalConfigurationException(message: "Invalid URL scheme for '{$url}'. Only 'http' and 'https' schemes are allowed.");
    }

    if (empty($parsed['host'])) {
        throw new CanonicalConfigurationException(message: "Missing host in URL: '{$url}'.");
    }
}
```

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

### Direct component instantiation for URL generation

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Non-trivial usage: instantiating the component directly and calling canonicalUrl() to generate the URL outside of a Blade template, e.g., for an og:url meta tag.

```php
use Fkrzski\LaravelCanonical\View\Components\Canonical;

$component = new Canonical(path: $post->canonical_path);
$url = $component->canonicalUrl();
```

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

### Pest: Assert canonical URL from current request

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Binds a request into the container to exercise the no-argument path. The staging host proves the URL is built from the canonical domain, not the request.

```php
use Illuminate\Http\Request;

it('canonicalises the current request', function (): void {
    $this->app->instance('request', Request::create('https://staging.example.com/blog/post'));

    expect(Canonical::generate())->toBe('https://example.com/blog/post');
});
```

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

### PHPUnit: Assert canonical URL from current request

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Binds a request into the container to exercise the no-argument path. The staging host proves the URL is built from the canonical domain, not the request.

```php
use Illuminate\Http\Request;

public function test_it_canonicalises_the_current_request(): void
{
    $this->app->instance(
        'request',
        Request::create('https://staging.example.com/blog/post'),
    );

    $this->assertSame('https://example.com/blog/post', Canonical::generate());
}
```

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

### Set canonical domain and trailing slash via environment variables

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/configuration.mdx

Use these environment variables to configure the canonical domain and trailing-slash trimming. The config file is optional; these values are read from the environment.

```dotenv
CANONICAL_DOMAIN=https://example.com
CANONICAL_TRIM_TRAILING_SLASH=true
```

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

### CanonicalConfigInterface

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/Contracts.md

Configuration accessor interface for canonical URL settings.

```APIDOC
## CanonicalConfigInterface

### Description
Provides configuration accessors consumed by the generator and the builder.

### Methods

#### getBaseUrl
- **Signature**: `public function getBaseUrl(): string`
- **Parameters**: None
- **Returns**: `string` - The validated canonical domain (trailing slash stripped).

#### shouldTrimTrailingSlash
- **Signature**: `public function shouldTrimTrailingSlash(): bool`
- **Parameters**: None
- **Returns**: `bool` - Whether trailing slashes are trimmed from generated URLs.
- **Since**: 1.1.0

### Usage Example
```php
use Fkrzski\LaravelCanonical\Contracts\CanonicalConfigInterface;

final class SeoMetaService
{
    public function __construct(
        private CanonicalConfigInterface $config
    ) {}

    public function canonicalDomain(): string
    {
        return $this->config->getBaseUrl();
    }
}
```

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

### Proxied generate() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalFacade.md

The facade inherits the generate() method from the resolved CanonicalUrlGeneratorInterface implementation. It accepts an optional path and returns the canonical URL string.

```php
Canonical::generate(?string $path = null): string
```

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

### CanonicalUrlBuilder::build()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Joins a base URL and path with exactly one slash, normalizes stray slashes, and optionally preserves or removes a trailing slash based on configuration.

```APIDOC
## CanonicalUrlBuilder::build()

### Description
Joins a base URL and path with exactly one slash, normalizes stray slashes, and optionally preserves or removes a trailing slash based on configuration.

### Method
build

### Signature
```php
public function build(string $baseUrl, string $path): string
```

### Parameters
- **baseUrl** (string) - Required - The canonical domain, e.g. `https://example.com`. A trailing slash is tolerated and normalized away.
- **path** (string) - Required - The path (or full current request URI) to join. Leading/trailing slashes are normalized; query strings pass through untouched, e.g. `/search?q=laravel&page=2`.

### Return Value
string - The joined, normalized URL.

### Behavior Matrix
Config `trim_trailing_slash` = `true` by default.

| Input path | trim=true (default) | trim=false |
| --- | --- | --- |
| `/blog/` | `https://example.com/blog` | `https://example.com/blog/` |
| `/blog` | `https://example.com/blog` | `https://example.com/blog` |
| `blog` | `https://example.com/blog` | `https://example.com/blog` |
| `/` | `https://example.com` | `https://example.com` |
| `` (empty) | `https://example.com` | `https://example.com` |
| `/blog/post/123` | `https://example.com/blog/post/123` | `https://example.com/blog/post/123/` |
| `/search?q=test` | `https://example.com/search?q=test` | `https://example.com/search?q=test` |

### Notes
- `shouldAddTrailingSlashForEmptyPath()` covers empty-path edge cases: with `trim=false`, an empty/root path appends `/` when either the input base URL or the input path ended in `/`.
```

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

### Generate canonical URL with Canonical facade

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/index.mdx

Returns the canonical URL as a string for the current request or a given path.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

Canonical::generate();                 // current request
Canonical::generate('/products/item'); // https://example.com/products/item
```

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

### Resolving via container

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Resolving the generator through the container, preserving query parameters.

```php
use Fkrzski\LaravelCanonical\Contracts\CanonicalUrlGeneratorInterface;

$url = app(CanonicalUrlGeneratorInterface::class)->generate('/search?q=laravel');
```

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

### Assert generated canonical URLs with Pest

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Use Pest expectations to verify that Canonical::generate returns the expected URL for a path and normalises the root path to the bare domain.

```php
it('generates a canonical URL for a path', function (): void {
    expect(Canonical::generate('/products/item'))
        ->toBe('https://example.com/products/item');
});

it('normalises the root path to the bare domain', function (): void {
    expect(Canonical::generate('/'))->toBe('https://example.com');
});
```

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

### Generate for Specific Paths

Source: https://github.com/fkrzski/laravel-canonical/blob/master/README.md

Use the Canonical facade to generate URLs for current or custom paths, preserving query parameters when not overridden.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

// Current request URI
Canonical::generate(); // https://example.com/blog

// Override with a custom path
Canonical::generate('/products/item'); // https://example.com/products/item

// Current request with query parameters (preserved)
// Request: /search?q=laravel&page=2
Canonical::generate(); // https://example.com/search?q=laravel&page=2

// Override path even when on different URL
// Current: /old-url, Generate: /new-canonical-url
Canonical::generate('/new-canonical-url'); // https://example.com/new-canonical-url
```

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

### generate(?string $path = null): string

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Generates a fully normalized canonical URL. If a path is provided, it is used; otherwise, the current request URI (including query string) is used. The base URL is fetched from the configuration and the builder normalizes the result.

```APIDOC
## generate(?string $path = null): string

### Description
Generates a fully normalized canonical URL. If a path is provided, it is used; otherwise, the current request URI (including query string) is used. The base URL is fetched from the configuration and the builder normalizes the result.

### Method
GENERATE

### Endpoint
N/A (PHP method)

### Parameters
#### Path Parameters
- **path** (?string) - Optional - Path to canonicalize. When null, the current request URI (including query string) is used via `request()->getRequestUri()`. A leading slash is optional; the root path `'/'` collapses to the bare domain.

### Request Example
```php
$generator->generate('/blog/post');
$generator->generate(); // uses current request URI
```

### Response
#### Success Response (200)
- **string** - The fully normalized canonical URL, e.g., `https://example.com/products/item`. Query parameters on `$path` or on the current request URI are preserved.

#### Response Example
```php
"https://example.com/blog/post"
```

### Error Handling
- **CanonicalConfigurationException** - Thrown when the first resolution of the generator builds `CanonicalConfig`, which validates the configured domain. Any of the four failure conditions (unset domain, invalid URL format, non-http(s) scheme, missing host) throw.
```

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

### Generate canonical URL with canonical() helper

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/index.mdx

Returns the canonical URL as a string for the current request or a given path.

```php
canonical()->generate();     // current request
canonical('/products/item'); // https://example.com/products/item
```

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

### Configure custom domain in config/canonical.php

Source: https://github.com/fkrzski/laravel-canonical/blob/master/README.md

This configuration file sets the canonical domain. It uses the CANONICAL_DOMAIN environment variable, falling back to the application's default URL. Useful for multi-domain environments where you need a specific canonical domain.

```php
// config/canonical.php
return [
    'domain' => env('CANONICAL_DOMAIN', config('app.url')),
];
```

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

### Catch CanonicalConfigurationException

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/guide.mdx

The domain is validated on first use. An unset or malformed domain throws CanonicalConfigurationException rather than emitting a broken tag.

```php
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

try {
    Canonical::generate('/page');
} catch (CanonicalConfigurationException $e) {
    // Domain missing, or not a valid http/https URL.
}
```

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

### PHPUnit: Assert rendered canonical component and directive

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Uses Blade::render() to test the canonical component and directive. Trims surrounding whitespace before comparing the rendered HTML.

```php
use Illuminate\Support\Facades\Blade;

public function test_it_renders_the_canonical_component(): void
{
    $html = trim(Blade::render('<x-canonical path="/products/item" />'));

    $this->assertSame(
        '<link rel="canonical" href="https://example.com/products/item" />',
        $html,
    );
}

public function test_it_renders_the_directive(): void
{
    $html = trim(Blade::render("@canonical('/products/item')"));

    $this->assertSame(
        '<link rel="canonical" href="https://example.com/products/item" />',
        $html,
    );
}
```

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

### getFacadeAccessor() method signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalFacade.md

The getFacadeAccessor() method returns the FQCN of the contract that the facade proxies. It is called by the framework for every static call on the facade.

```php
public static function getFacadeAccessor(): string
```

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

### canonical() helper signature

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Signature of the canonical() helper. It returns a string when called with a path, or the generator when called without arguments. Throws CanonicalConfigurationException.

```php
canonical(?string $path = null): CanonicalUrlGeneratorInterface|string
```

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

### Constructor for CanonicalUrlBuilder

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Constructor with injected CanonicalConfigInterface property.

```php
public function __construct(
    private CanonicalConfigInterface $config
) {}
```

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

### config/canonical.php - canonical domain and trailing slash settings

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/configuration.md

Full configuration file for the Laravel Canonical package. Defines the canonical domain, falling back to APP_URL and then 'http://localhost', and controls trailing slash trimming with the CANONICAL_TRIM_TRAILING_SLASH environment variable (default true).

```php
<?php

declare(strict_types=1);

/**
 * Configuration file for Laravel Canonical
 *
 * You can publish this file with:
 * php artisan vendor:publish --tag="canonical-config"
 */
return [
    /*
    |--------------------------------------------------------------------------
    | Canonical Domain
    |--------------------------------------------------------------------------
    |
    | This value is the canonical domain that will be used for generating
    | canonical URLs. If not specified, it will fall back to APP_URL
    | environment variable.
    |
    */
    'domain' => env('CANONICAL_DOMAIN', env('APP_URL', 'http://localhost')),

    /*
    |--------------------------------------------------------------------------
    | Trim Trailing Slash
    |--------------------------------------------------------------------------
    |
    | Determines whether trailing slashes should be removed from generated
    | canonical URLs. When set to true, URLs like /blog/ will be normalized
    | to /blog. When set to false, the original URL format is preserved.
    |
    | @since 1.1.0
    |
    */
    'trim_trailing_slash' => env('CANONICAL_TRIM_TRAILING_SLASH', true),
];
```

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

### Error handling around generate()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalFacade.md

Catch CanonicalConfigurationException when calling generate() to handle configuration issues like missing domain, invalid URL, wrong scheme, or no host. Log the error message for debugging.

```php
use Fkrzski\LaravelCanonical\Facades\Canonical;
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

try {
    $url = Canonical::generate('/page');
} catch (CanonicalConfigurationException $e) {
    // Domain missing, not a valid URL, wrong scheme, or no host
    Log::error('canonical misconfiguration', ['message' => $e->getMessage()]);
}
```

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

### Canonical::generate()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/api-reference.mdx

Builds the canonical URL for a given path, joined onto the configured canonical domain. With no argument it canonicalises the current request URI, query string included.

```APIDOC
## Canonical::generate()

### Description
Builds the canonical URL for the given path, joined onto the configured canonical domain. With no argument it canonicalises the current request URI, query string included.

### Method
PHP method

### Signature
`Canonical::generate(?string $path = null): string`

### Parameters
- **$path** (?string) - Optional - Path to canonicalise. If null, uses the current request URI.

### Returns
- **string** - The canonical URL.

### Exceptions
- **CanonicalConfigurationException** - Thrown when the domain is not set, invalid, or has an invalid scheme.

### Example
```php
use Fkrzski\LaravelCanonical\Facades\Canonical;

Canonical::generate();                 // current request
Canonical::generate('/products/item'); // https://example.com/products/item
Canonical::generate('/');              // https://example.com
```
```

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

### Pest test for rejecting a domain without a scheme

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Use this Pest test to verify that Canonical::generate throws CanonicalConfigurationException when the canonical.domain config lacks a scheme. The domain is only validated on first use, so the test must trigger generation.

```php
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

it('rejects a domain without a scheme', function (): void {
    config(['canonical.domain' => 'example.com']);

    expect(fn (): string => Canonical::generate('/page'))
        ->toThrow(CanonicalConfigurationException::class);
});
```

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

### resolveCurrentPath() private method

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlGenerator.md

Private method that returns the current request URI including query string.

```php
private function resolveCurrentPath(): string
{
    return request()->getRequestUri();
}
```

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

### Assert generated canonical URLs with PHPUnit

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Use PHPUnit assertions to verify that Canonical::generate returns the expected URL for a path and normalises the root path to the bare domain.

```php
public function test_it_generates_a_canonical_url_for_a_path(): void
{
    $this->assertSame(
        'https://example.com/products/item',
        Canonical::generate('/products/item'),
    );
}

public function test_it_normalises_the_root_path_to_the_bare_domain(): void
{
    $this->assertSame('https://example.com', Canonical::generate('/'));
}
```

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

### validate()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/BaseUrlValidator.md

Validates the canonical domain URL. Throws CanonicalConfigurationException on invalid URL format, scheme, or missing host.

```APIDOC
## validate()

### Description
Validates the canonical domain URL. Stateless and side-effect free; the only enforcement mechanism is throwing `CanonicalConfigurationException` per failure mode.

### Method
validate

### Signature
`public function validate(string $url): void`

### Parameters
- **url** (string) - Required - The domain to validate. Callers pass the **trimmed** domain (trailing `/` already removed).

### Return Value
`void` — returns normally only when every check passes.

### Throws
- `CanonicalConfigurationException` - If `filter_var($url, FILTER_VALIDATE_URL)` is false — the value is not a syntactically valid URL (e.g. missing scheme: `example.com`). Message: `Invalid URL format: '<url>'. Expected a valid URL.`
- `CanonicalConfigurationException` - If the parsed URL has no `scheme` key, or the scheme (case-sensitive strict comparison) is not `http` or `https` (e.g. `ftp://example.com`). Message: `Invalid URL scheme for '<url>'. Only 'http' and 'https' schemes are allowed.`
- `CanonicalConfigurationException` - If the parsed URL has an empty `host`. Message: `Missing host in URL: '<url>'.`

### Validation Order
1. `FILTER_VALIDATE_URL` check runs first
2. Scheme check
3. Host check

The first failing rule determines the exception message.

### Usage Examples

Basic — valid domains pass silently:

```php
use Fkrzski\LaravelCanonical\Validation\BaseUrlValidator;

$validator = new BaseUrlValidator();

$validator->validate('https://example.com');       // ok
$validator->validate('https://example.com:8000');  // ok (port allowed)
$validator->validate('https://www.example.com');   // ok (subdomain allowed)
$validator->validate('http://localhost');          // ok (http allowed)
```

Error handling — invalid domains throw with a specific message:

```php
use Fkrzski\LaravelCanonical\Validation\BaseUrlValidator;
use Fkrzski\LaravelCanonical\Exceptions\CanonicalConfigurationException;

$validator = new BaseUrlValidator();

try {
    $validator->validate('ftp://example.com');
} catch (CanonicalConfigurationException $e) {
    // "Invalid URL scheme for 'ftp://example.com'. Only 'http' and 'https' schemes are allowed."
}
```
```

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

### canonicalUrl()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalViewComponent.md

Generates the canonical URL for the component's path. Invokes the global `canonical()` helper and calls `generate()` on the resulting generator.

```APIDOC
## `canonicalUrl(): string`

### Description
Generates the canonical URL for the component's path. Invokes the global `canonical()` helper and calls `generate()` on the resulting generator.

### Parameters
None.

### Returns
`string` - The normalized canonical URL for the configured domain and `$this->path` (or the current request URI when `path` is `null`).

### Throws
- `CanonicalConfigurationException` - Propagated from `CanonicalConfig` construction on first container resolution when the domain is unset or invalid.
```

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

### Basic Blade template usage of canonical()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalHelperFunction.md

Usage in a Blade template showcasing direct URL generation, fluent generator usage, and usage with current request URL.

```blade
<head>
    {{-- Direct URL generation --}}
    <link rel="canonical" href="{{ canonical('/products/item') }}" />

    {{-- Fluent usage (without arguments returns generator) --}}
    <link rel="canonical" href="{{ canonical()->generate('/products/item') }}" />

    {{-- Use current request URL --}}
    <link rel="canonical" href="{{ canonical()->generate() }}" />

    {{-- Also works in PHP code --}}
    @php
        $url = canonical('/products/item'); // Returns: "https://example.com/products/item"
        $generator = canonical(); // Returns: CanonicalUrlGeneratorInterface instance
    @endphp
</head>
```

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

### CanonicalUrlBuilder::__construct()

Source: https://github.com/fkrzski/laravel-canonical/blob/master/_autodocs/api-reference/CanonicalUrlBuilder.md

Constructor that injects the CanonicalConfigInterface dependency used for trailing slash configuration.

```APIDOC
## CanonicalUrlBuilder::__construct()

### Description
Constructor that injects the CanonicalConfigInterface dependency used for trailing slash configuration.

### Method
Constructor

### Signature
```php
public function __construct(
    private CanonicalConfigInterface $config
) {}
```

### Parameters
- **config** (CanonicalConfigInterface) - Required - Provides `shouldTrimTrailingSlash()`. See [CanonicalConfig.md](CanonicalConfig.md).

### Returns
No explicit return value (constructor).
```

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

### Pest: Assert rendered canonical component and directive

Source: https://github.com/fkrzski/laravel-canonical/blob/master/docs/testing.mdx

Uses Blade::render() to test the canonical component and directive. Trims surrounding whitespace before comparing the rendered HTML.

```php
use Illuminate\Support\Facades\Blade;

it('renders the canonical component', function (): void {
    $html = trim(Blade::render('<x-canonical path="/products/item" />'));

    expect($html)->toBe('<link rel="canonical" href="https://example.com/products/item" />');
});

it('renders the directive', function (): void {
    $html = trim(Blade::render("@canonical('/products/item')"));

    expect($html)->toBe('<link rel="canonical" href="https://example.com/products/item" />');
});
```
Tokens:
Raw