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

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. ritechoice23/laravel-reactions

ActiveLibrary[Database & ORM](/categories/database)

ritechoice23/laravel-reactions
==============================

A simple, flexible Laravel package for adding polymorphic reactions to any model. React with any text: like, love, care, or anything you want.

1.0.0(6mo ago)1363↓100%[3 PRs](https://github.com/ritechoice23/laravel-reactions/pulls)1MITPHPPHP ^8.2CI passing

Since Nov 8Pushed 1mo agoCompare

[ Source](https://github.com/ritechoice23/laravel-reactions)[ Packagist](https://packagist.org/packages/ritechoice23/laravel-reactions)[ Docs](https://github.com/ritechoice23/laravel-reactions)[ GitHub Sponsors](https://github.com/ritechoice23)[ RSS](/packages/ritechoice23-laravel-reactions/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (1)Dependencies (12)Versions (3)Used By (1)

Laravel Reactions
=================

[](#laravel-reactions)

[![Latest Version on Packagist](https://camo.githubusercontent.com/857eef97d606ff47b0cfb71862e0ecff0118190e2b6db8b8ffc8b6e49ab33ced/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f7269746563686f69636532332f6c61726176656c2d7265616374696f6e732e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/ritechoice23/laravel-reactions)[![GitHub Tests Action Status](https://camo.githubusercontent.com/88045b621571b2f1391dd2e696e5701129c3a6224be5608a52b28d911af1129c/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f7269746563686f69636532332f6c61726176656c2d7265616374696f6e732f72756e2d74657374732e796d6c3f6272616e63683d6d6173746572266c6162656c3d7465737473267374796c653d666c61742d737175617265)](https://github.com/ritechoice23/laravel-reactions/actions?query=workflow%3Arun-tests+branch%3Amaster)[![GitHub Code Style Action Status](https://camo.githubusercontent.com/19382ffbc3b99ee87978e074dcaf45d3a41cbb926656da31f459a005c5fd277a/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f7269746563686f69636532332f6c61726176656c2d7265616374696f6e732f6669782d7068702d636f64652d7374796c652d6973737565732e796d6c3f6272616e63683d6d6173746572266c6162656c3d636f64652532307374796c65267374796c653d666c61742d737175617265)](https://github.com/ritechoice23/laravel-reactions/actions?query=workflow%3A%22Fix+PHP+code+style+issues%22+branch%3Amaster)[![Total Downloads](https://camo.githubusercontent.com/89245ee9ed1aeaa9e8df19f7d1ea8ab82542f0d8d3bef82479d30d9d6b753e58/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f7269746563686f69636532332f6c61726176656c2d7265616374696f6e732e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/ritechoice23/laravel-reactions)

A simple, flexible Laravel package for adding polymorphic reactions to any Eloquent model. React with any text - like, love, care, celebrate, or even custom emojis 🔥💯. Unlimited flexibility with full polymorphic relationship support.

Table of Contents
-----------------

[](#table-of-contents)

- [Why This Package?](#why-this-package)
- [Features](#features)
- [Installation](#installation)
- [Configuration](#configuration)
- [Usage](#usage)
    - [Setup Models](#setup-models)
    - [Basic Operations](#basic-operations)
    - [Working with Reactions on Models](#working-with-reactions-on-models)
    - [Query Scopes](#query-scopes)
    - [Advanced Queries](#advanced-queries)
    - [Filtering Reactions](#filtering-reactions)
    - [Polymorphic Reactions](#polymorphic-reactions)
    - [Custom Reaction Types](#custom-reaction-types)
- [Practical Examples](#practical-examples)
    - [Social Media Feed](#social-media-feed)
    - [Trending Content Dashboard](#trending-content-dashboard)
    - [User Profile Reactions](#user-profile-reactions)
    - [Reaction Analytics](#reaction-analytics)
- [Important Notes](#important-notes)
    - [Update or Create Behavior](#update-or-create-behavior)
    - [Unique Constraint](#unique-constraint)
    - [Performance Considerations](#performance-considerations)
    - [Database Indexes](#database-indexes)
    - [Reaction Validation](#reaction-validation)
- [API Reference](#api-reference)
    - [CanReact Trait Methods](#canreact-trait-methods)
    - [CanReact Trait Scopes](#canreact-trait-scopes)
    - [HasReactions Trait Methods](#hasreactions-trait-methods)
    - [HasReactions Trait Scopes](#hasreactions-trait-scopes)
    - [Reaction Model Scopes](#reaction-model-scopes)
- [Testing](#testing)
- [Changelog](#changelog)
- [Contributing](#contributing)
- [Security Vulnerabilities](#security-vulnerabilities)
- [Credits](#credits)
- [License](#license)

Why This Package?
-----------------

[](#why-this-package)

### The Simplest Yet Most Flexible Reaction System

[](#the-simplest-yet-most-flexible-reaction-system)

While there are several reaction packages available for Laravel, this package offers the perfect balance of **simplicity** and **flexibility** - designed for developers who want powerful features without unnecessary complexity.

### Popular Alternatives

[](#popular-alternatives)

- [cybercog/laravel-love](https://github.com/cybercog/laravel-love) - Feature-rich but complex (weighted reactions, reputation systems)
- [thedevdojo/laravel-reactions](https://github.com/thedevdojo/laravel-reactions) - Limited to predefined emoji sets
- [qirolab/laravel-reactions](https://github.com/qirolab/laravel-reactions) - Good but less flexible reaction types

### What Makes This Package Unique

[](#what-makes-this-package-unique)

✅ **Unlimited Flexibility** - React with ANY text, not limited to predefined emoji sets like Facebook/Discord
✅ **Update-or-Create Logic** - Automatically updates existing reactions (no duplicate prevention code needed)
✅ **Comprehensive Analytics** - Built-in `reactionsBreakdown()` method for instant statistics
✅ **Trending Scopes** - `mostReacted()` scope for viral content discovery out of the box
✅ **User-Specific Status** - `withReactionStatus()` scope prevents N+1 queries in feeds
✅ **Developer-First API** - Intuitive method naming: `react()`, `unreact()`, `hasReactedTo()`, `reactionTo()`
✅ **Zero Configuration** - Works immediately with sensible defaults, configure only when needed
✅ **Performance Optimized** - Efficient database queries with proper indexing and eager loading support

### Key Differentiator

[](#key-differentiator)

> **"React with anything, anywhere, anytime."**
> Use emojis 🔥, text reactions, or custom strings - no predefined limitations. The package adapts to your needs, not the other way around.

**This package** is intentionally simpler, more flexible, and easier to integrate - perfect for **80% of use cases without the overhead**. You get:

- Drop-in installation (2 minutes)
- Intuitive API that feels native to Laravel
- Full polymorphic support for any model combination
- Production-ready with comprehensive test coverage

### Perfect For

[](#perfect-for)

- Social media platforms and feeds
- Content management systems
- Community forums and discussion boards
- E-learning platforms with interactive content
- Any application needing flexible user engagement

Features
--------

[](#features)

- **Fully Polymorphic**: Any model can react to any other model (User → Post, User → Comment, Team → Article, etc.)
- **Flexible Reaction Types**: Use any text as reaction type - "like", "love", "celebrate", "🔥", "💯", or anything you want
- **Simple API**: Intuitive methods like `react()`, `unreact()`, `hasReactedTo()`, `reactionTo()`
- **Rich Analytics**: Get reaction counts, breakdowns by type, and most popular reactions
- **Expressive Scopes**: Chainable query scopes like `reactedTo()`, `reactedWith()`, `mostReacted()`
- **Update or Create**: Changing a reaction automatically updates the existing one (no duplicates)
- **Zero Configuration**: Works out of the box with sensible defaults
- **Full Test Coverage**: Comprehensive Pest PHP test suite included

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

[](#installation)

Install the package via composer:

```
composer require ritechoice23/laravel-reactions
```

Publish and run the migrations:

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

Optionally, publish the config file:

```
php artisan vendor:publish --tag="laravel-reactions-config"
```

Configuration
-------------

[](#configuration)

The published config file (`config/reactions.php`) includes:

```
return [
    'table_name' => 'reactions',
    'default_reaction_type' => 'like',
];
```

Usage
-----

[](#usage)

### Setup Models

[](#setup-models)

Add traits to your models:

```
use Illuminate\Database\Eloquent\Model;
use Ritechoice23\Reactions\Traits\CanReact;
use Ritechoice23\Reactions\Traits\HasReactions;

class User extends Model
{
    use CanReact;      // Can react to other models
}

class Post extends Model
{
    use HasReactions;   // Can receive reactions
}

class Comment extends Model
{
    use CanReact;      // Can react to posts
    use HasReactions;   // Can also receive reactions
}
```

### Basic Operations

[](#basic-operations)

```
// React to a model with default type (like)
$user->react($post);

// React with a specific type
$user->react($post, 'love');
$user->react($comment, 'celebrate');
$user->react($article, '🔥');

// Change reaction (automatically updates)
$user->react($post, 'like');
$user->react($post, 'love');  // Changes from 'like' to 'love'

// Remove reaction
$user->unreact($post);

// Check if user has reacted
if ($user->hasReactedTo($post)) {
    // User has reacted to the post
}

// Get the reaction type
$reactionType = $user->reactionTo($post);  // Returns 'love' or null
```

### Working with Reactions on Models

[](#working-with-reactions-on-models)

#### Get Reaction Statistics

[](#get-reaction-statistics)

```
// Get total reaction count
$count = $post->reactionsCount();

// Get reaction breakdown by type
$breakdown = $post->reactionsBreakdown();
// Returns: ['like' => 45, 'love' => 32, 'celebrate' => 18, '🔥' => 12]

// Check if a specific user has reacted
if ($post->isReactedBy($user)) {
    // This user has reacted to the post
}

// Get a specific user's reaction
$reaction = $post->reactionBy($user);  // Returns Reaction model or null
if ($reaction) {
    echo $reaction->reaction_type;  // 'love'
    echo $reaction->created_at;     // When they reacted
}

// Remove a specific user's reaction
$post->removeReaction($user);
```

#### Accessing Reaction Relationships

[](#accessing-reaction-relationships)

```
// Get all reactions for a post
$reactions = $post->reactions;  // Collection of Reaction models

// Get all reactions given by a user
$reactionsGiven = $user->reactionsGiven;  // Collection of Reaction models

// Eager load relationships
$posts = Post::with('reactions')->get();

// Access reactor and reactable
foreach ($post->reactions as $reaction) {
    $reactor = $reaction->reactor;        // The User who reacted
    $reactable = $reaction->reactable;    // The Post that was reacted to
    $type = $reaction->reaction_type;     // The reaction type
}
```

### Query Scopes

[](#query-scopes)

Find models based on reaction relationships:

```
// Find all users who reacted to a post
$users = User::reactedTo($post)->get();

// Find all users who reacted with a specific type
$loveUsers = User::reactedWith($post, 'love')->get();

// Chain with other queries
$activeUsers = User::reactedTo($post)
    ->where('status', 'active')
    ->orderBy('created_at', 'desc')
    ->get();
```

### Advanced Queries

[](#advanced-queries)

#### Eager Loading Reaction Counts

[](#eager-loading-reaction-counts)

```
// Load posts with reaction counts
$posts = Post::withReactionsCount()->get();

foreach ($posts as $post) {
    echo $post->reactions_count;
}
```

#### Get Most Reacted Posts

[](#get-most-reacted-posts)

```
// Get top 10 most reacted posts
$topPosts = Post::mostReacted(10)->get();

// Custom limit
$topPosts = Post::mostReacted(5)->get();

// Combine with other queries
$topRecentPosts = Post::mostReacted(10)
    ->where('created_at', '>', now()->subWeek())
    ->get();
```

#### Check Reaction Status for Current User

[](#check-reaction-status-for-current-user)

```
// Add reaction status for a specific user to query results
$posts = Post::withReactionStatus($currentUser)->get();

foreach ($posts as $post) {
    // Check if current user has reacted
    if ($post->has_reacted) {
        echo "You reacted with: " . $post->reactor_reaction_type;
    } else {
        echo "You haven't reacted yet";
    }
}
```

### Filtering Reactions

[](#filtering-reactions)

The `Reaction` model includes useful scopes:

```
use Ritechoice23\Reactions\Models\Reaction;

// Get all reactions by type
$loveReactions = Reaction::byType('love')->get();

// Get all reactions by a specific reactor
$userReactions = Reaction::byReactor($user)->get();

// Get all reactions to a specific model
$postReactions = Reaction::byReactable($post)->get();

// Combine filters
$userLoveReactions = Reaction::byReactor($user)
    ->byType('love')
    ->get();
```

### Polymorphic Reactions

[](#polymorphic-reactions)

React to any model type:

```
// Users reacting to posts
$user->react($post, 'love');

// Users reacting to comments
$user->react($comment, 'like');

// Teams reacting to articles (if Team uses CanReact)
$team->react($article, 'celebrate');

// Comments reacting to posts (nested reactions)
$comment->react($post, '🔥');
```

### Custom Reaction Types

[](#custom-reaction-types)

Use any text as a reaction type:

```
// Standard reactions
$user->react($post, 'like');
$user->react($post, 'love');
$user->react($post, 'care');
$user->react($post, 'wow');
$user->react($post, 'sad');
$user->react($post, 'angry');

// Custom text
$user->react($post, 'inspired');
$user->react($post, 'mindblown');
$user->react($post, 'thankful');

// Emojis
$user->react($post, '🔥');
$user->react($post, '💯');
$user->react($post, '❤️');
$user->react($post, '😂');
$user->react($post, '🎉');

// The sky's the limit!
$user->react($post, 'chef-kiss');
$user->react($post, 'big-brain');
```

Practical Examples
------------------

[](#practical-examples)

### Social Media Feed

[](#social-media-feed)

```
// Display post with reactions
class PostController extends Controller
{
    public function show(Post $post)
    {
        $post->load('reactions');

        $breakdown = $post->reactionsBreakdown();
        $totalReactions = $post->reactionsCount();
        $userReaction = $post->reactionBy(auth()->user());

        return view('posts.show', compact('post', 'breakdown', 'totalReactions', 'userReaction'));
    }

    public function react(Post $post, Request $request)
    {
        $request->validate([
            'type' => 'required|string|max:50'
        ]);

        auth()->user()->react($post, $request->type);

        return back()->with('success', 'Reacted!');
    }

    public function unreact(Post $post)
    {
        auth()->user()->unreact($post);

        return back()->with('success', 'Reaction removed!');
    }
}
```

### Trending Content Dashboard

[](#trending-content-dashboard)

```
// Get trending posts
public function trending()
{
    // Posts with most reactions in the last 24 hours
    $trendingPosts = Post::mostReacted(10)
        ->where('created_at', '>', now()->subDay())
        ->with(['reactions' => function($query) {
            $query->select('reactable_id', 'reaction_type')
                  ->selectRaw('count(*) as count')
                  ->groupBy('reactable_id', 'reaction_type');
        }])
        ->get();

    return view('trending', compact('trendingPosts'));
}
```

### User Profile Reactions

[](#user-profile-reactions)

```
// Show all posts a user has reacted to
public function userReactions(User $user)
{
    $reactedPosts = Post::whereHas('reactions', function($query) use ($user) {
        $query->byReactor($user);
    })
    ->with(['reactions' => function($query) use ($user) {
        $query->byReactor($user);
    }])
    ->paginate(20);

    return view('profile.reactions', compact('user', 'reactedPosts'));
}
```

### Reaction Analytics

[](#reaction-analytics)

```
// Get analytics for a post
public function analytics(Post $post)
{
    $breakdown = $post->reactionsBreakdown();
    $totalReactions = $post->reactionsCount();

    // Get reactions over time
    $reactionsTimeline = $post->reactions()
        ->selectRaw('DATE(created_at) as date, reaction_type, count(*) as count')
        ->groupBy('date', 'reaction_type')
        ->orderBy('date')
        ->get()
        ->groupBy('date');

    // Get top reactors
    $topReactors = Reaction::byReactable($post)
        ->with('reactor')
        ->get()
        ->groupBy('reactor_id')
        ->map(fn($reactions) => [
            'reactor' => $reactions->first()->reactor,
            'count' => $reactions->count()
        ])
        ->sortByDesc('count')
        ->take(10);

    return view('analytics', compact('post', 'breakdown', 'totalReactions', 'reactionsTimeline', 'topReactors'));
}
```

Important Notes
---------------

[](#important-notes)

### Update or Create Behavior

[](#update-or-create-behavior)

When a model reacts to the same model again with a different type, the package automatically updates the existing reaction instead of creating a duplicate:

```
$user->react($post, 'like');
// Database: 1 reaction of type 'like'

$user->react($post, 'love');
// Database: Still 1 reaction, now type 'love' (updated, not duplicated)
```

### Unique Constraint

[](#unique-constraint)

The migration includes a unique constraint to prevent duplicates at the database level:

```
$table->unique(['reactor_type', 'reactor_id', 'reactable_type', 'reactable_id'], 'unique_reaction');
```

This ensures one reactor can only have one reaction per reactable model at any time.

### Performance Considerations

[](#performance-considerations)

The package uses optimized database queries:

- **Indexed columns**: All foreign keys and reaction types are indexed
- **Eager loading support**: Use `with()` and `withCount()` to avoid N+1 queries
- **Efficient scopes**: Query scopes use optimized joins and subqueries
- **Unique constraints**: Prevents duplicate data at the database level

```
// ✅ Good - Efficient
$posts = Post::with('reactions')
    ->withReactionsCount()
    ->mostReacted(10)
    ->get();

// ❌ Bad - N+1 queries
$posts = Post::all();
foreach ($posts as $post) {
    $count = $post->reactions()->count();  // N+1 query
}
```

### Database Indexes

[](#database-indexes)

The migration includes optimized indexes for performance:

- Unique composite index on reactor and reactable (prevents duplicates)
- Index on reactable\_type and reactable\_id (for lookups)
- Index on reactor\_type and reactor\_id (for reverse lookups)
- Index on reaction\_type (for filtering by type)

### Reaction Validation

[](#reaction-validation)

Validate reaction types in your controller:

```
public function react(Post $post, Request $request)
{
    $request->validate([
        'type' => 'required|in:like,love,celebrate,wow,sad,angry'
    ]);

    auth()->user()->react($post, $request->type);

    return response()->json(['success' => true]);
}
```

API Reference
-------------

[](#api-reference)

### CanReact Trait Methods

[](#canreact-trait-methods)

MethodParametersReturnDescription`react()``Model $model, ?string $type = null``Reaction`React to a model (creates or updates)`unreact()``Model $model``bool`Remove reaction from a model`hasReactedTo()``Model $model``bool`Check if has reacted to a model`reactionTo()``Model $model``?string`Get reaction type to a model`reactionsGiven()`-`MorphMany`Relationship: all reactions given### CanReact Trait Scopes

[](#canreact-trait-scopes)

ScopeParametersDescription`reactedTo()``Model $model`Models that reacted to a specific model`reactedWith()``Model $model, string $type`Models that reacted with a specific type### HasReactions Trait Methods

[](#hasreactions-trait-methods)

MethodParametersReturnDescription`reactions()`-`MorphMany`Relationship: all reactions received`reactionsCount()`-`int`Total number of reactions`reactionsBreakdown()`-`array`Reaction count by type`isReactedBy()``Model $reactor``bool`Check if reacted by a specific model`reactionBy()``Model $reactor``?Reaction`Get reaction by a specific model`removeReaction()``Model $reactor``bool`Remove a specific model's reaction### HasReactions Trait Scopes

[](#hasreactions-trait-scopes)

ScopeParametersDescription`withReactionsCount()`-Eager load reaction count`mostReacted()``int $limit = 10`Order by most reacted`withReactionStatus()``Model $reactor`Add reaction status for a specific reactor### Reaction Model Scopes

[](#reaction-model-scopes)

ScopeParametersDescription`byType()``string $type`Filter reactions by type`byReactor()``Model $reactor`Filter reactions by reactor`byReactable()``Model $reactable`Filter reactions by reactableTesting
-------

[](#testing)

Run the test suite:

```
composer test
```

Run tests with coverage:

```
composer test-coverage
```

Run static analysis:

```
composer analyse
```

Run code formatting:

```
composer format
```

Changelog
---------

[](#changelog)

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

Contributing
------------

[](#contributing)

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

Security Vulnerabilities
------------------------

[](#security-vulnerabilities)

Please review [our security policy](../../security/policy) on how to report security vulnerabilities.

Credits
-------

[](#credits)

- [Daramola Babatunde Ebenezer](https://github.com/ritechoice23)
- [All Contributors](../../contributors)

License
-------

[](#license)

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

###  Health Score

41

—

FairBetter than 89% of packages

Maintenance81

Actively maintained with recent releases

Popularity15

Limited adoption so far

Community11

Small or concentrated contributor base

Maturity48

Maturing project, gaining track record

 Bus Factor1

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

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

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

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

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

###  Release Activity

Cadence

Unknown

Total

1

Last Release

185d ago

### Community

Maintainers

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

---

Top Contributors

[![ritechoice23](https://avatars.githubusercontent.com/u/62488893?v=4)](https://github.com/ritechoice23 "ritechoice23 (2 commits)")[![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)](https://github.com/dependabot[bot] "dependabot[bot] (1 commits)")[![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?v=4)](https://github.com/github-actions[bot] "github-actions[bot] (1 commits)")

---

Tags

laravel-frameworklaravel-packagelaravel-reactionlaravel-reactionsmarkablelaravelmodeleloquenttraitcontentsocialreactemojifeedbackengagementlikelovereactionspolymorphicritechoice23user-interaction

###  Code Quality

TestsPest

Static AnalysisPHPStan

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/ritechoice23-laravel-reactions/health.svg)

```
[![Health](https://phpackages.com/badges/ritechoice23-laravel-reactions/health.svg)](https://phpackages.com/packages/ritechoice23-laravel-reactions)
```

###  Alternatives

[dyrynda/laravel-model-uuid

This package allows you to easily work with UUIDs in your Laravel models.

4802.8M8](/packages/dyrynda-laravel-model-uuid)[cybercog/laravel-love

Make Laravel Eloquent models reactable with any type of emotions in a minutes!

1.2k302.7k1](/packages/cybercog-laravel-love)[devdojo/laravel-reactions

3529.7k](/packages/devdojo-laravel-reactions)[lacodix/laravel-model-filter

A Laravel package to filter, search and sort models with ease while fetching from database.

17649.9k](/packages/lacodix-laravel-model-filter)[rtconner/laravel-likeable

Trait for Laravel Eloquent models to allow easy implementation of a 'like' or 'favorite' or 'remember' feature.

394388.0k5](/packages/rtconner-laravel-likeable)[esensi/model

The base model traits of Esensi

20266.5k1](/packages/esensi-model)

PHPackages © 2026

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