├── .gitignore
├── composer.json
├── readme.md
└── src
    ├── Classes
        └── PackageChecker.php
    ├── Http
        ├── Controllers
        │   └── PackageCheckerController.php
        └── Services
        │   └── PackageCheckerService.php
    ├── Providers
        └── PackageCheckerServiceProvider.php
    ├── config
        └── package-checker.php
    ├── resources
        └── views
        │   └── list.blade.php
    └── routes
        └── web.php


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | vendor/
3 | ```


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "iinmass/laravel-package-checker",
 3 |     "description": "A powerful tool for managing package dependencies in Laravel projects. Get insights into package versions, installation status, and sizes.",
 4 |     "type": "library",
 5 |     "autoload": {
 6 |         "psr-4": {
 7 |             "Iinmass\\LaravelPackageChecker\\": "src/"
 8 |         }
 9 |     },
10 |     "keywords": [
11 |         "laravel",
12 |         "package",
13 |         "checker",
14 |         "dependency",
15 |         "management"
16 |     ],
17 |     "license": "MIT",
18 |     "extra": {
19 |         "laravel": {
20 |             "providers": [
21 |                 "Iinmass\\LaravelPackageChecker\\Providers\\PackageCheckerServiceProvider"
22 |             ]
23 |         }
24 |     },
25 |     "version": "2.1.1",
26 |     "authors": [
27 |         {
28 |             "name": "iinmass",
29 |             "email": "inmass.idbel@gmail.com",
30 |             "role": "Developer"
31 |         }
32 |     ],
33 |     "minimum-stability": "stable",
34 |     "require": {
35 |         "php": "^8.0",
36 |         "illuminate/support": "^9.0|^10.0",
37 |         "laravel/framework": "9.*|10.*",
38 |         "guzzlehttp/guzzle": "^7.0"
39 |     },
40 |     "require-dev": {
41 |         "phpunit/phpunit": "^9.0",
42 |         "vimeo/psalm": "^4.30"
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/inmass/laravel-package-checker/blob/main/LICENSE)
 2 | [![Latest Stable Version](https://img.shields.io/packagist/v/iinmass/laravel-package-checker.svg)](https://packagist.org/packages/iinmass/laravel-package-checker)
 3 | 
 4 | 
 5 | ## Features
 6 | 
 7 | Retrieves a list of packages required in your project's composer.json file.
 8 | Displays the current version, latest version, installation status, and size for each package.
 9 | Offers a treemap visualization of the vendor directory, showing the size distribution of packages.
10 | Helps optimize project dependencies by highlighting large packages.
11 | Easy installation and seamless integration with your existing project.
12 | 
13 | ## Description
14 | 
15 | Package Checker is a powerful tool that provides insights into the packages used in your project. It helps you manage your project's dependencies, keeping you informed about the current and latest versions of each package, their installation status, and their sizes. The package also offers a treemap visualization that displays the size distribution of packages within your vendor directory, allowing you to identify large packages that might require optimization.
16 | 
17 | ## Installation
18 | 
19 | The Laravel Package Checker can be easily installed via Composer. Run the following command in your terminal:
20 | 
21 | ```bash
22 | composer require iinmass/laravel-package-checker
23 | ```
24 | 
25 | After the installation is complete, the package will be ready to use in your Laravel project.
26 | 
27 | ## Usage
28 | 
29 | To access the Package Checker, navigate to the following URL in your web browser: `http://your-app-url/package-checker/list`.
30 | This page provides a comprehensive overview of your Laravel project's packages, including the required packages from composer.json, their versions, installation status, and sizes as well as the tree of all the packages and their dependencies.
31 | 
32 | ## Configuration
33 | 
34 | The Laravel Package Checker requires no additional configuration. It seamlessly integrates with your Laravel project and retrieves the necessary information from the composer.json file and vendor directory.
35 | 
36 | Alternatively, you can publish the package's configuration file and customize it to suit your needs by running the following command in your terminal:
37 | ```bash
38 | php artisan vendor:publish --tag=package-checker-config
39 | ```
40 | 
41 | ## Contributing
42 | 
43 | Contributions to the Laravel Package Checker are welcome! If you would like to contribute to the project, please follow these steps:
44 | 
45 | 1. Fork the repository.
46 | 2. Create a new branch for your feature or fix.
47 | 3. Make the necessary modifications.
48 | 4. Commit your changes.
49 | 5. Push the branch to your fork.
50 | 6. Submit a pull request.
51 | Please ensure that your code adheres to the project's coding standards and includes appropriate tests.
52 | 
53 | ## License
54 | 
55 | The Laravel Package Checker is open-source software licensed under the [MIT license](https://opensource.org/licenses/MIT).
56 | 
57 | ## Credits
58 | 
59 | The Laravel Package Checker is developed and maintained by [inmass](https://github.com/inmass)
60 | 
61 | ## Support
62 | 
63 | If you encounter any issues or have any questions, please create a new issue on the [issue tracker](https://github.com/inmass/laravel-package-checker/issues). I will be happy to assist you.


--------------------------------------------------------------------------------
/src/Classes/PackageChecker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Iinmass\LaravelPackageChecker\Classes;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | 
 7 | class PackageChecker extends Facade
 8 | {
 9 |     public static function getFacadeAccessor()
10 |     {
11 |         return 'laravel-package-checker';
12 |     }
13 | }


--------------------------------------------------------------------------------
/src/Http/Controllers/PackageCheckerController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Iinmass\LaravelPackageChecker\Http\Controllers;
 4 | 
 5 | use Illuminate\Routing\Controller as BaseController;
 6 | USE Iinmass\LaravelPackageChecker\Classes\PackageChecker;
 7 | 
 8 | class PackageCheckerController extends BaseController
 9 | {
10 |     public function listPackages()
11 |     {
12 |         return view('package-checker::list');
13 |     }
14 | 
15 |     public function getInstalledPackages()
16 |     {
17 |         $installedPackages = PackageChecker::getInstalledPackages();
18 |         return response()->json($installedPackages);
19 |     }
20 | 
21 |     public function getPackageDetails()
22 |     {
23 |         $data = [
24 |             'name' => request('name'),
25 |             'version' => request('version'),
26 |         ];
27 | 
28 |         $requirements = PackageChecker::getPackageDetailsFor($data);
29 |         return response()->json($requirements);
30 |     }
31 | 
32 |     public function getLatestVersion()
33 |     {
34 |         $name = request('name');
35 |         $latestVersion = PackageChecker::getLatestVersion($name);
36 |         return response()->json($latestVersion);
37 |     }
38 | 
39 |     public function getPackageSize()
40 |     {
41 |         $name = request('name');
42 |         $requirements = request('requirements') ?? [];
43 |         if (!$name) {
44 |             return response()->json(['error' => 'Invalid request']);
45 |         }
46 |         $packageSize = PackageChecker::getPackageSize($name, $requirements);
47 |         return response()->json($packageSize);
48 |     }
49 | 
50 |     public function getVendorSize()
51 |     {
52 |         $vendorSize = PackageChecker::getAllPackageSizes();
53 |         $headOfResponse = [];
54 |         $index = 0;
55 |         foreach ($vendorSize as $package) {
56 |             $headOfResponse[] = [
57 |                 'id' => 'ID_' . $index,
58 |                 'name' => '',
59 |                 'color' => '#' . substr(md5(rand()), 0, 6)
60 |             ];
61 |             $index++;
62 |         }
63 |         $vendorSize = collect($vendorSize)->map(function ($item, $key) {
64 |             return [
65 |                 'name' => $item['name'],
66 |                 'parent' => 'ID_' . $key,
67 |                 'value' => (int)$item['size'],
68 |             ];
69 |         });
70 |         $vendorSize = array_merge($headOfResponse, $vendorSize->toArray());
71 |         return response()->json($vendorSize);
72 |     }
73 | }


--------------------------------------------------------------------------------
/src/Http/Services/PackageCheckerService.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Iinmass\LaravelPackageChecker\Http\Services;
  4 | 
  5 | 
  6 | class PackageCheckerService {
  7 | 
  8 |     /**
  9 |      * Get the installed packages infos
 10 |      * 
 11 |      * @return array
 12 |      */
 13 |     public function getPackagesInfo($packages)
 14 |     {
 15 |         $client = new \GuzzleHttp\Client();
 16 |         $promises = [];
 17 | 
 18 |         // Create a promise for each package request
 19 |         foreach ($packages as $packageName) {
 20 |             $packageName = $packageName['name'];
 21 |             $uri = "https://packagist.org/packages/$packageName.json";
 22 |             $promises[$packageName] = $client->getAsync($uri);
 23 |         }
 24 | 
 25 |         // Wait for all the requests to complete
 26 |         $results = \GuzzleHttp\Promise\Utils::settle($promises)->wait();
 27 | 
 28 |         $this->packagesInfo = $results;
 29 |     }
 30 | 
 31 |     /**
 32 |      * Get the installed packages
 33 |      * 
 34 |      * @return array
 35 |      */
 36 |     public function getInstalledPackages(): array
 37 |     {
 38 |         $packages = [];
 39 | 
 40 |         // read the composer.json
 41 |         $composerJson = file_get_contents(base_path('composer.json'));
 42 | 
 43 |         // convert JSON to an associative array
 44 |         $composerConfig = json_decode($composerJson, true);
 45 | 
 46 |         // get the installed packages
 47 |         $installedPackages = $composerConfig['require'];
 48 | 
 49 |         // check if found and remove the php version
 50 |         if (isset($installedPackages['php'])) {
 51 |             unset($installedPackages['php']);
 52 |         }
 53 |         // remove php extensions
 54 |         foreach ($installedPackages as $key => $value) {
 55 |             if (str_contains($key, 'ext-')) {
 56 |                 unset($installedPackages[$key]);
 57 |             }
 58 |         }
 59 | 
 60 |         // remove the "^" from the version number
 61 |         foreach ($installedPackages as $key => $value) {
 62 |             $installedPackages[$key] = str_replace('^', '', str_replace('v', '', $value));
 63 |             // append to the packages array
 64 |             $packages[] = [
 65 |                 'name' => $key,
 66 |                 'version' => $installedPackages[$key],
 67 |                 'latest_version' => '',
 68 |                 'status' => '',
 69 |                 'release_date' => '',
 70 |                 'requirements' => '',
 71 |                 'size' => ''
 72 |             ];
 73 |         }
 74 | 
 75 |         return $packages;
 76 |     }
 77 | 
 78 | 
 79 |     /**
 80 |      * Get package information from packagist.org
 81 |      * 
 82 |      * @param string $packageName
 83 |      * @return string
 84 |      */
 85 |     private function getPackageInfo(string $packageName): array|bool
 86 |     {
 87 |         $client = new \GuzzleHttp\Client();
 88 | 
 89 |         try {
 90 |             $response = $client->get("https://packagist.org/packages/$packageName.json");
 91 |             return json_decode($response->getBody()->getContents(), true) ?? false;
 92 |         } catch (\GuzzleHttp\Exception\ClientException $e) {
 93 |             // means the package is not found
 94 |             return false;
 95 |         }
 96 |     }
 97 | 
 98 |     /**
 99 |      * Get the latest version of the package
100 |      * 
101 |      * @param string $packageName
102 |      * @return string
103 |      */
104 |     public function getLatestVersion(array $packageInfo): string
105 |     {
106 |         if (!$packageInfo) {
107 |             return 'Package not found';
108 |         }
109 | 
110 |         // If default_branch is set, it is generally the latest stable version
111 |         if (isset($packageInfo['package']['default_branch'])) {
112 |             $latestVersion = $packageInfo['package']['default_branch'];
113 |             // Ensure this branch version exists in versions list and doesn't contain "-dev"
114 |             if (isset($packageInfo['package']['versions'][$latestVersion]) && strpos($latestVersion, '-dev') === false) {
115 |                 return  str_replace('v', '', $latestVersion);
116 |             }
117 |         }
118 | 
119 |         // Find the latest stable version manually, ignoring versions with "-dev", "-alpha", "-beta", or "-RC"
120 |         foreach ($packageInfo['package']['versions'] as $version => $details) {
121 |             if (!preg_match('/(dev|alpha|beta|RC)/', $version)) {
122 |                 // remove the "v" from the version number
123 |                 return str_replace('v', '', $version);
124 |             }
125 |         }
126 | 
127 |         return 'No stable version found';
128 |     }
129 | 
130 |     /**
131 |      * Get the status of the packages
132 |      * 
133 |      * @param array $installedPackages
134 |      * @return array
135 |      */
136 |     public function getPackageDetailsFor(array $package): array
137 |     {
138 |         $packageInfo = $this->getPackageInfo($package['name']);
139 | 
140 |         if (!$packageInfo) {
141 |             return $this->createPackageNotFoundResponse();
142 |         }
143 | 
144 |         $desiredVersions = $this->filterDesiredVersions($packageInfo['package']['versions'], $package['version']);
145 | 
146 |         if (empty($desiredVersions)) {
147 |             $latestVersion = $this->getLatestVersion($packageInfo);
148 |             return $this->createUnknownVersionResponse($latestVersion);
149 |         }
150 | 
151 |         $desiredVersion = end($desiredVersions);
152 |         $versionReleaseDate = new \DateTime($desiredVersion['time']);
153 |         $status = $this->determineVersionStatus($versionReleaseDate);
154 | 
155 |         $versionRequirements = $desiredVersion ? $this->extractVersionRequirements($desiredVersion['require']) : [];
156 | 
157 |         return [
158 |             'status' => $status,
159 |             'release_date' => $versionReleaseDate ? $versionReleaseDate->format('Y-m-d') : '---',
160 |             'requirements' => $versionRequirements,
161 |             'latest_version' => $this->getLatestVersion($packageInfo)
162 |         ];
163 |     }
164 | 
165 |     /**
166 |      * Filter the desired versions based on the installed version
167 |      *
168 |      * @param array $versions
169 |      * @param string $installedVersion
170 |      * @return array
171 |      */
172 |     private function filterDesiredVersions(array $versions, string $installedVersion): array
173 |     {
174 |         return array_filter($versions, function ($versionData) use ($installedVersion) {
175 |             if (isset($versionData['version']) && is_string($versionData['version'])) {
176 |                 $version = ltrim($versionData['version'], 'v');
177 |                 return preg_match("/^" . preg_quote($installedVersion, '/') . "/", $version);
178 |             }
179 |             return false;
180 |         });
181 |     }
182 | 
183 |     /**
184 |      * Determine the status of the version based on the release date
185 |      *
186 |      * @param \DateTime $releaseDate
187 |      * @return string
188 |      */
189 |     private function determineVersionStatus(\DateTime $releaseDate): string
190 |     {
191 |         $now = new \DateTime();
192 |         $diff = $now->diff($releaseDate);
193 | 
194 |         if ($diff->y >= 2) {
195 |             return 'very_old';
196 |         } elseif ($diff->y >= 1) {
197 |             return 'old';
198 |         } else {
199 |             return 'good';
200 |         }
201 |     }
202 | 
203 |     /**
204 |      * Extract the version requirements, removing the PHP requirement if present
205 |      *
206 |      * @param array $requirements
207 |      * @return array
208 |      */
209 |     private function extractVersionRequirements(array $requirements): array
210 |     {
211 |         if (isset($requirements['php'])) {
212 |             unset($requirements['php']);
213 |         }
214 |         return array_keys($requirements);
215 |     }
216 | 
217 |     /**
218 |      * Create a response for the package not found scenario
219 |      *
220 |      * @return array
221 |      */
222 |     private function createPackageNotFoundResponse(): array
223 |     {
224 |         return [
225 |             'status' => 'Package not found',
226 |             'release_date' => '---',
227 |             'requirements' => []
228 |         ];
229 |     }
230 | 
231 |     /**
232 |      * Create a response for the unknown version scenario
233 |      *
234 |      * @return array
235 |      */
236 |     private function createUnknownVersionResponse(string $latestVersion): array
237 |     {
238 |         return [
239 |             'status' => 'Unknown version',
240 |             'release_date' => '---',
241 |             'requirements' => [],
242 |             'latest_version' => $latestVersion
243 |         ];
244 |     }
245 | 
246 | 
247 |     /**
248 |      * Get the size of the package
249 |      * 
250 |      * @param string $packageName
251 |      * @return string
252 |      */
253 |     public function getPackageSize(string $packageName, array $requirements): string
254 |     {
255 |         $packagePath = base_path("vendor/$packageName");
256 | 
257 |         if (!file_exists($packagePath)) {
258 |             return '---';
259 |         }
260 | 
261 |         $size = $this->getDirectorySize($packagePath);
262 | 
263 |         // if package has requirements
264 |         if (!empty($requirements)) {
265 |             foreach ($requirements as $requirement) {
266 |                 $requirementPath = base_path("vendor/$requirement");
267 |                 if (file_exists($requirementPath)) {
268 |                     $size += $this->getDirectorySize($requirementPath) ?? 0;
269 |                 }
270 |             }
271 |         }
272 | 
273 |         return self::formatBytes($size);
274 |     }
275 | 
276 |     /**
277 |      * Get the size of the directory
278 |      * 
279 |      * @param string $directory
280 |      * @return string
281 |      */
282 |     private function getDirectorySize(string $directory): string
283 |     {
284 |         $size = 0;
285 |         foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($directory)) as $file) {
286 |             if ($file->isFile()) {
287 |                 $size += $file->getSize();
288 |             }
289 |         }
290 | 
291 |         return $size;
292 |     }
293 | 
294 |     /**
295 |      * Format bytes to human readable format
296 |      * 
297 |      * @param int $bytes
298 |      * @param int $precision
299 |      * @return string
300 |      */
301 |     public static function formatBytes(int $bytes): string
302 |     {
303 |         $units = array('B', 'KB', 'MB', 'GB', 'TB');
304 |         $i = 0;
305 |         while ($bytes >= 1024 && $i < count($units) - 1) {
306 |             $bytes /= 1024;
307 |             $i++;
308 |         }
309 |         return round($bytes, 2) . ' ' . $units[$i];
310 |     }
311 | 
312 |     /**
313 |      * Get the names and sizes of all packages in the vendor directory.
314 |      *
315 |      * @return array
316 |      */
317 |     public function getAllPackageSizes(): array
318 |     {
319 |         $packages = $this->getAllPackageNames();
320 | 
321 |         foreach ($packages as $key => $value) {
322 |             $size = $this->getDirectorySize($value['path']);
323 |             $packages[$key]['size'] = $size;
324 |         }
325 |         return $packages;
326 |     }
327 | 
328 |     /**
329 |      * Get the names of all packages in the vendor directory.
330 |      * 
331 |      * @return array
332 |      */
333 |     public function getAllPackageNames(): array
334 |     {
335 |         $installedPackagesFile = base_path('vendor/composer/installed.php');
336 |         // get returned array from installed.php
337 |         if (!file_exists($installedPackagesFile)) {
338 |             return [];
339 |         }
340 |         $installedPackagesArray = (require $installedPackagesFile)['versions'] ?? [];
341 | 
342 |         foreach ($installedPackagesArray as $key => $value) {
343 |             if (!isset($value['install_path'])) {
344 |                 continue;
345 |             }
346 |             if (strpos($value['install_path'], '/../../') !== false) {
347 |                 continue;
348 |             }
349 |             $packages[] = [
350 |                 'name' => $key,
351 |                 'path' => $value['install_path'],
352 |             ];
353 |         }
354 | 
355 |         return $packages;
356 |     }
357 | 
358 | }


--------------------------------------------------------------------------------
/src/Providers/PackageCheckerServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Iinmass\LaravelPackageChecker\Providers;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | use Illuminate\Support\Facades\Route;
 7 | 
 8 | class PackageCheckerServiceProvider extends ServiceProvider
 9 | {
10 | 
11 |     /**
12 |      * Register services.
13 |      *
14 |      * @return void
15 |      */
16 |     public function register()
17 |     {
18 |         app()->bind('laravel-package-checker', function () {
19 |             return new \Iinmass\LaravelPackageChecker\Http\Services\PackageCheckerService();
20 |         });
21 |     }
22 | 
23 | 
24 |     public function boot()
25 |     {
26 |         if ($this->app->runningInConsole()) {
27 |             $this->setPublishers();
28 |         }
29 |         
30 |         $this->loadConfig();
31 |         $this->loadRoutes();
32 |         $this->loadViews();
33 | 
34 |     }
35 | 
36 |     public function setPublishers()
37 |     {
38 |         $this->publishes([
39 |             __DIR__ . '/../config/package-checker.php' => config_path('package-checker.php')
40 |         ], 'package-checker-config');
41 |     }
42 | 
43 |     /**
44 |      * Group the routes and set up configurations to load them.
45 |      *
46 |      * @return void
47 |      */
48 |     protected function loadRoutes()
49 |     {
50 |         Route::group($this->routesConfigurations(), function () {
51 |             $this->loadRoutesFrom(__DIR__.'/../routes/web.php');
52 |         });
53 |     }
54 | 
55 |     /**
56 |      * Routes configurations.
57 |      *
58 |      * @return array
59 |      */
60 |     private function routesConfigurations()
61 |     {
62 |         return [
63 |             'prefix' => config('package-checker.routes.prefix'),
64 |             'middleware' => config('package-checker.routes.middleware'),
65 |             'namespace' => config('package-checker.routes.namespace'),
66 |         ];
67 |     }
68 | 
69 |     /**
70 |      * Load views.
71 |      *
72 |      * @return void
73 |      */
74 |     protected function loadViews()
75 |     {
76 |         $this->loadViewsFrom(__DIR__.'/../resources/views', 'package-checker');
77 |     }
78 | 
79 |     /**
80 |      * Load config.
81 |      *
82 |      * @return array
83 |      */
84 |     protected function loadConfig()
85 |     {
86 |         $this->mergeConfigFrom(
87 |             __DIR__.'/../config/package-checker.php', 'package-checker'
88 |         );
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/config/package-checker.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     'routes' => [
5 |         'prefix' => env('PACKAGE_CHECKER_ROUTES_PREFIX', 'package-checker'),
6 |         'middleware' => env('PACKAGE_CHECKER_ROUTES_MIDDLEWARE', ['web','auth']),
7 |         'namespace' => 'Iinmass\LaravelPackageChecker\Http\Controllers',
8 |     ],
9 | ];


--------------------------------------------------------------------------------
/src/resources/views/list.blade.php:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Package List</title>
  7 |     @csrf
  8 | 
  9 |     <!-- Add Bootstrap for table styling (optional) -->
 10 |     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css">
 11 | </head>
 12 | <body>
 13 |     <div class="container mt-5">
 14 |         <h1 class="mb-4">Package List</h1>
 15 |         <h4>This is a list of all the packages required in your project's composer.json file.</h4>
 16 |         <p>You can also see every installed package on your vendor from the <a href="#chart_div">chart below</a>.</p>
 17 | 
 18 |         <div class="mb-4">
 19 |             <p>Package Statuses:</p>
 20 |             <span class="badge badge-success">Good</span>
 21 |             <span class="badge badge-warning">Old</span>
 22 |             <span class="badge badge-danger">Very Old</span>
 23 |         </div>
 24 | 
 25 |         <table class="table table-striped" id="packages-table">
 26 |             <thead>
 27 |                 <tr>
 28 |                     <th scope="col">Package Name</th>
 29 |                     <th scope="col">Package Requirements</th>
 30 |                     <th scope="col">Version</th>
 31 |                     <th scope="col">Latest Version</th>
 32 |                     <th scope="col">Status</th>
 33 |                     <th scope="col">Release Date</th>
 34 |                     <th scope="col">Size</th>
 35 |                 </tr>
 36 |             </thead>
 37 |             <tbody>
 38 |                 <tr>
 39 |                     <td colspan="7" class="text-center">
 40 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
 41 |                         Loading...
 42 |                     </td>
 43 |                 </tr>
 44 |             </tbody>
 45 |         </table>
 46 |         <hr>
 47 | 
 48 |     </div>
 49 |     <div id="chart_div" style="width: 100%; height: 1000px;"></div>
 50 | </body>
 51 | <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
 52 | <script>
 53 |     // get data for the table
 54 |     $.ajax({
 55 |         url: "{{ route('package-checker.get-installed-packages') }}",
 56 |         method: 'GET',
 57 |         success: function(response) {
 58 |             let table = $('#packages-table');
 59 |             // remove loading message
 60 |             table.find('tbody tr').remove();
 61 |             response.forEach(function(item) {
 62 |                 // fill the table
 63 |                 let row = `<tr>
 64 |                     <td>${item.name}</td>
 65 |                     <td class="package-requirements" data-package-name="${item.name}" data-package-version="${item.version}">
 66 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
 67 |                     </td>
 68 |                     <td>${item.version}</td>
 69 |                     <td class="package-latest-version" data-package-name="${item.name}">
 70 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>    
 71 |                     </td>
 72 |                     <td class="package-status" data-package-name="${item.name}">
 73 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
 74 |                     </td>
 75 |                     <td class="package-release-date" data-package-name="${item.name}">
 76 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
 77 |                     </td>
 78 |                     <td class="package-size" data-package-name="${item.name}" >
 79 |                         <span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span>
 80 |                     </td>
 81 |                 </tr>`;
 82 |                 table.append(row);
 83 |             });
 84 |             getPackagesDetails();
 85 | 
 86 |         }
 87 |     });
 88 | 
 89 | 
 90 |     function getPackagesDetails()
 91 |     {
 92 |         jQuery('.package-requirements').each(function() {
 93 |             var packageName = jQuery(this).data('package-name');
 94 |             var packageVersion = jQuery(this).data('package-version');
 95 | 
 96 |             var packageRequirements = jQuery(this);
 97 |             var packageStatus = jQuery('.package-status[data-package-name="' + packageName + '"]');
 98 |             var packageReleaseDate = jQuery('.package-release-date[data-package-name="' + packageName + '"]');
 99 |             var packageSize = jQuery('.package-size[data-package-name="' + packageName + '"]');
100 |             var packageLatestVersion = jQuery('.package-latest-version[data-package-name="' + packageName + '"]');
101 | 
102 |             jQuery.ajax({
103 |                 url: "{{ route('package-checker.get-package-details') }}", // "http://localhost:8000/package-checker/get-requirements/?name=" + packageName,
104 |                 method: 'GET',
105 |                 // async: false,
106 |                 data: {
107 |                     name: packageName,
108 |                     version: packageVersion,
109 |                 },
110 |                 success: function(response) {
111 |                     // fill status, release date and requirements
112 |                     // release date
113 |                     packageRequirements.html('');
114 |                     if (response.requirements.length === 0) {
115 |                         packageRequirements.append('<span class="badge badge-secondary">No known requirements</span>');
116 |                     } else {
117 |                         let requirements = '';
118 |                         response.requirements.forEach(function(requirement) {
119 |                             requirements += `<span class="badge badge-primary mr-1">${requirement}</span>`;
120 |                         });
121 |                         packageRequirements.append(requirements);
122 |                         // append requirements to package-size as json
123 |                         packageSize.attr('data-package-requirements', JSON.stringify(response.requirements));
124 |                     }
125 | 
126 | 
127 |                     // status
128 |                     packageStatus.html('');
129 |                     if (response.status === 'good') {
130 |                         packageStatus.append('<span class="badge badge-success">Good</span>');
131 |                     } else if (response.status === 'old') {
132 |                         packageStatus.append('<span class="badge badge-warning">Old</span>');
133 |                     } else if (response.status === 'very_old') {
134 |                         packageStatus.append('<span class="badge badge-danger">Very Old</span>');
135 |                     } else {
136 |                         packageStatus.append(response.status);
137 |                     }
138 | 
139 |                     // release date
140 |                     packageReleaseDate.html('');
141 |                     packageReleaseDate.append(response.release_date);
142 | 
143 |                     // latest version
144 |                     packageLatestVersion.html('');
145 |                     packageLatestVersion.append(response.latest_version);
146 | 
147 |                     getVendorSize(packageName);
148 |                 }
149 |             });
150 |         });
151 |     }
152 | 
153 |     function getVendorSize(packageName)
154 |     {
155 |         let packageSize = jQuery('.package-size[data-package-name="' + packageName + '"]');
156 |         let packageRequirements = packageSize.data('package-requirements');
157 |         let payload = {
158 |             name: packageName,
159 |             requirements: packageRequirements,
160 |         };
161 |         jQuery.ajax({
162 |             url: "{{ route('package-checker.get-size') }}", // "http://localhost:8000/package-checker/get-size/?name=" + packageName,
163 |             method: 'POST',
164 |             headers: {
165 |                 'X-CSRF-TOKEN': "{{ csrf_token() }}"
166 |             },
167 |             data: payload,
168 |             success: function(response) {
169 |                 packageSize.html(response);
170 |             }
171 |         });
172 |     }
173 | 
174 | 
175 | </script>
176 | <script src="https://code.highcharts.com/highcharts.js"></script>
177 | <script src="https://code.highcharts.com/modules/treemap.js"></script>
178 | <script src="https://code.highcharts.com/modules/exporting.js"></script>
179 | <script src="https://code.highcharts.com/modules/accessibility.js"></script>
180 | 
181 | <script type="text/javascript">
182 | 
183 |     var url = "{{ route('package-checker.get-vendor-size') }}";
184 |     let vendorTotalSize = 0;
185 |     $.ajax({
186 |         url: url,
187 |         method: 'GET',
188 |         success: function(response) {
189 |             response.forEach(function(item) {
190 |                 if (item.value) {
191 |                     vendorTotalSize += item.value;
192 |                 }
193 |             });
194 |             vendorTotalSize = formatSizeUnits(vendorTotalSize);
195 |             drawChart(response);
196 |         }
197 |     });
198 | 
199 |     function formatSizeUnits(bytes) {
200 |         if (bytes === 0) {
201 |             return '0 B';
202 |         }
203 |         const units = ['B', 'KB', 'MB', 'GB', 'TB'];
204 |         let i = 0;
205 | 
206 |         while (bytes >= 1024 && i < units.length - 1) {
207 |             bytes /= 1024;
208 |             i++;
209 |         }
210 | 
211 |         return Math.round(bytes * 100) / 100 + ' ' + units[i];
212 |     }
213 | 
214 |     function drawChart(data) {
215 |         Highcharts.chart('chart_div', {
216 |         series: [{
217 |             type: 'treemap',
218 |             layoutAlgorithm: 'stripes',
219 |             alternateStartingDirection: true,
220 |             borderColor: '#fff',
221 |             borderRadius: 0,
222 |             borderWidth: 2,
223 |             dataLabels: {
224 |                 style: {
225 |                     textOutline: 'none'
226 |                 }
227 |             },
228 |             levels: [{
229 |                 level: 1,
230 |                 layoutAlgorithm: 'squarified',
231 |                 dataLabels: {
232 |                     enabled: true,
233 |                     align: 'left',
234 |                     verticalAlign: 'top',
235 |                     style: {
236 |                         fontSize: '15px',
237 |                         fontWeight: 'bold'
238 |                     }
239 |                 }
240 |             }],
241 |             data: data
242 |         }],
243 |         title: {
244 |             text: 'Vendor Packages Sizes',
245 |             align: 'left'
246 |         },
247 |         subtitle: {
248 |             text: `Here you can see the size of each vendor package<br>PS: The size of your vendor is: ${vendorTotalSize}`,
249 |             align: 'left'
250 |         },
251 |         tooltip: {
252 |             useHTML: true,
253 |             formatter: function() {
254 |                 return 'The size of <b>' + this.point.name + '</b> is <b>' + formatSizeUnits(this.point.value) + '</b>';
255 |             }
256 |         }
257 |     });
258 | 
259 |             
260 |     }
261 | 
262 | 
263 | </script>
264 | </html>
265 | 


--------------------------------------------------------------------------------
/src/routes/web.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\Facades\Route;
 4 | 
 5 | Route::get('/list', 'PackageCheckerController@listPackages')->name('package-checker.list');
 6 | Route::get('/get-installed-packages', 'PackageCheckerController@getInstalledPackages')->name('package-checker.get-installed-packages');
 7 | Route::get('/get-package-details', 'PackageCheckerController@getPackageDetails')->name('package-checker.get-package-details');
 8 | Route::get('/get-latest-version', 'PackageCheckerController@getLatestVersion')->name('package-checker.get-latest-version');
 9 | Route::post('/get-size', 'PackageCheckerController@getPackageSize')->name('package-checker.get-size');
10 | Route::get('/get-vendor-size', 'PackageCheckerController@getVendorSize')->name('package-checker.get-vendor-size');
11 | 


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