[9.x] Makes blade components blazing fast ⛽️

src/Illuminate/View/Compilers/Concerns/CompilesComponents.php

@@ -64,7 +64,7 @@ public static function compileClassComponentOpening(string $component, string $a
     {
         return implode("\n", [
             '<?php if (isset($component)) { $__componentOriginal'.$hash.' = $component; } ?>',
-            '<?php $component = $__env->getContainer()->make('.Str::finish($component, '::class').', '.($data ?: '[]').' + (isset($attributes) ? (array) $attributes->getIterator() : [])); ?>',
+            '<?php $component = '.$component.'::resolve('.($data ?: '[]').' + (isset($attributes) ? (array) $attributes->getIterator() : [])); ?>',
             '<?php $component->withName('.$alias.'); ?>',
             '<?php if ($component->shouldRender()): ?>',
             '<?php $__env->startComponent($component->resolveView(), $component->data()); ?>',

src/Illuminate/View/Component.php

@@ -12,6 +12,27 @@
 
 abstract class Component
 {
+    /**
+     * The components resolver used withing views.
+     *
+     * @var (\Closure(string, array): Component)|null
+     */
+    protected static $componentsResolver;
+
+    /**
+     * The cache of blade view names, keyed by contents.
+     *
+     * @var array<string, string>
+     */
+    protected static $bladeViewCache = [];
+
+    /**
+     * The view factory instance, if any.
+     *
+     * @var \Illuminate\Contracts\View\Factory|null
+     */
+    protected static $factory;
+
     /**
      * The cache of public property names, keyed by class.
      *
@@ -26,6 +47,13 @@ abstract class Component
      */
     protected static $methodCache = [];
 
+    /**
+     * The cache of constructor parameters, keyed by class.
+     *
+     * @var array<class-string, array<int, string>>
+     */
+    protected static $constructorParametersCache = [];
+
     /**
      * The properties / methods that should not be exposed to the component.
      *
@@ -72,11 +100,7 @@ public function resolveView()
         }
 
         $resolver = function ($view) {
-            $factory = Container::getInstance()->make('view');
-
-            return strlen($view) <= PHP_MAXPATHLEN && $factory->exists($view)
-                        ? $view
-                        : $this->createBladeViewFromString($factory, $view);
+            return $this->extractBladeViewFromString($view);
         };
 
         return $view instanceof Closure ? function (array $data = []) use ($view, $resolver) {
@@ -88,13 +112,22 @@ public function resolveView()
     /**
      * Create a Blade view with the raw component string content.
      *
-     * @param  \Illuminate\Contracts\View\Factory  $factory
      * @param  string  $contents
      * @return string
      */
-    protected function createBladeViewFromString($factory, $contents)
+    protected function extractBladeViewFromString($contents)
     {
-        $factory->addNamespace(
+        $key = sprintf('%s::%s', static::class, $contents);
+
+        if (isset(static::$bladeViewCache[$key])) {
+            return static::$bladeViewCache[$key];
+        }
+
+        if (strlen($contents) <= PHP_MAXPATHLEN && $this->factory()->exists($contents)) {
+            return static::$bladeViewCache[$key] = $contents;
+        }
+
+        $this->factory()->addNamespace(
             '__components',
             $directory = Container::getInstance()['config']->get('view.compiled')
         );
@@ -107,7 +140,7 @@ protected function createBladeViewFromString($factory, $contents)
             file_put_contents($viewFile, $contents);
         }
 
-        return '__components::'.basename($viewFile, '.blade.php');
+        return static::$bladeViewCache[$key] = '__components::'.basename($viewFile, '.blade.php');
     }
 
     /**
@@ -292,4 +325,121 @@ public function shouldRender()
     {
         return true;
     }
+
+    /**
+     * Flush the components cache.
+     *
+     * @return void
+     */
+    public static function flushCache()
+    {
+        static::$bladeViewCache = [];
+        static::$constructorParametersCache = [];
+        static::$methodCache = [];
+        static::$propertyCache = [];
+    }
+
+    /**
+     * Get the evaluated view contents for the given view.
+     *
+     * @param  string|null  $view
+     * @param  \Illuminate\Contracts\Support\Arrayable|array  $data
+     * @param  array  $mergeData
+     * @return \Illuminate\Contracts\View\View
+     */
+    public function view($view, $data = [], $mergeData = [])
+    {
+        return $this->factory()->make($view, $data, $mergeData);
+    }
+
+    /**
+     * Get the view factory.
+     *
+     * @return \Illuminate\Contracts\View\Factory
+     */
+    protected function factory()
+    {
+        if (is_null(static::$factory)) {
+            static::$factory = Container::getInstance()->make('view');
+        }
+
+        return static::$factory;
+    }
+
+    /**
+     * Forget the component's factory.
+     *
+     * @return void
+     */
+    public static function forgetFactory()
+    {
+        static::$factory = null;
+    }
+
+    /**
+     * Forget the component resolver.
+     *
+     * @return void
+     *
+     * @internal
+     */
+    public static function forgetComponentsResolver()
+    {
+        static::$componentsResolver = null;
+    }
+
+    /**
+     * Acts as static factory for the component.
+     *
+     * @param  array  $data
+     * @return static
+     */
+    public static function resolve($data)
+    {
+        if (static::$componentsResolver) {
+            return call_user_func(static::$componentsResolver, static::class, $data);
+        }
+
+        $parameters = static::extractConstructorParameters();
+
+        $dataKeys = array_keys($data);
+
+        if (empty(array_diff($parameters, $dataKeys))) {
+            return new static(...array_intersect_key($data, array_flip($parameters)));
+        }
+
+        return Container::getInstance()->make(static::class, $data);
+    }
+
+    /**
+     * Set the callback to be used to resolve components within views.
+     *
+     * @param  \Closure(string $component, array $data): Component  $resolver
+     * @return void
+     *
+     * @internal
+     */
+    public static function resolveComponentsUsing($resolver)
+    {
+        static::$componentsResolver = $resolver;
+    }
+
+    /**
+     * Extract the constructor parameters for the component.
+     *
+     * @return array
+     */
+    protected static function extractConstructorParameters()
+    {
+        if (! isset(static::$constructorParametersCache[static::class])) {
+            $class = new ReflectionClass(static::class);
+            $constructor = $class->getConstructor();
+
+            static::$constructorParametersCache[static::class] = $constructor
+                ? collect($constructor->getParameters())->map->getName()->all()
+                : [];
+        }
+
+        return static::$constructorParametersCache[static::class];
+    }
 }

src/Illuminate/View/Concerns/ManagesEvents.php

@@ -4,10 +4,25 @@
 
 use Closure;
 use Illuminate\Contracts\View\View as ViewContract;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
 
 trait ManagesEvents
 {
+    /**
+     * If the factory should call the creators.
+     *
+     * @var array<string, true>|true
+     */
+    protected $shouldCallCreators = [];
+
+    /**
+     * If the factory should call the composers.
+     *
+     * @var array<string, true>|true
+     */
+    protected $shouldCallComposers = [];
+
     /**
      * Register a view creator event.
      *
@@ -17,6 +32,16 @@ trait ManagesEvents
      */
     public function creator($views, $callback)
     {
+        if (is_array($this->shouldCallCreators)) {
+            if ($views == '*') {
+                $this->shouldCallCreators = true;
+            } else {
+                foreach (Arr::wrap($views) as $view) {
+                    $this->shouldCallCreators[$this->normalizeName($view)] = true;
+                }
+            }
+        }
+
         $creators = [];
 
         foreach ((array) $views as $view) {
@@ -52,6 +77,16 @@ public function composers(array $composers)
      */
     public function composer($views, $callback)
     {
+        if (is_array($this->shouldCallComposers)) {
+            if ($views == '*') {
+                $this->shouldCallComposers = true;
+            } else {
+                foreach (Arr::wrap($views) as $view) {
+                    $this->shouldCallComposers[$this->normalizeName($view)] = true;
+                }
+            }
+        }
+
         $composers = [];
 
         foreach ((array) $views as $view) {
@@ -174,7 +209,11 @@ protected function addEventListener($name, $callback)
      */
     public function callComposer(ViewContract $view)
     {
-        $this->events->dispatch('composing: '.$view->name(), [$view]);
+        if ($this->shouldCallComposers === true || isset($this->shouldCallComposers[
+            $this->normalizeName($view->name())
+        ])) {
+            $this->events->dispatch('composing: '.$view->name(), [$view]);
+        }
     }
 
     /**
@@ -185,6 +224,10 @@ public function callComposer(ViewContract $view)
      */
     public function callCreator(ViewContract $view)
     {
-        $this->events->dispatch('creating: '.$view->name(), [$view]);
+        if ($this->shouldCallCreators === true || isset($this->shouldCallCreators[
+            $this->normalizeName((string) $view->name())
+        ])) {
+            $this->events->dispatch('creating: '.$view->name(), [$view]);
+        }
     }
 }

src/Illuminate/View/Engines/CompilerEngine.php

@@ -16,6 +16,13 @@ class CompilerEngine extends PhpEngine
      */
     protected $compiler;
 
+    /**
+     * The caches paths that were compiled or are not expired, keyed by paths.
+     *
+     * @var array<string, true>
+     */
+    protected $compiledOrNotExpired = [];
+
     /**
      * A stack of the last compiled templates.
      *
@@ -51,10 +58,12 @@ public function get($path, array $data = [])
         // If this given view has expired, which means it has simply been edited since
         // it was last compiled, we will re-compile the views so we can evaluate a
         // fresh copy of the view. We'll pass the compiler the path of the view.
-        if ($this->compiler->isExpired($path)) {
+        if (! isset($this->compiledOrNotExpired[$path]) && $this->compiler->isExpired($path)) {
             $this->compiler->compile($path);
         }
 
+        $this->compiledOrNotExpired[$path] = true;
+
         // Once we have the path to the compiled file, we will evaluate the paths with
         // typical PHP just like any other templates. We also keep a stack of views
         // which have been rendered for right exception messages to be generated.
@@ -101,4 +110,14 @@ public function getCompiler()
     {
         return $this->compiler;
     }
+
+    /**
+     * Forgets the views that were compiled or not expired.
+     *
+     * @return void
+     */
+    public function forgetCompiledOrNotExpired()
+    {
+        $this->compiledOrNotExpired = [];
+    }
 }

src/Illuminate/View/ViewServiceProvider.php

@@ -22,6 +22,10 @@ public function register()
         $this->registerViewFinder();
         $this->registerBladeCompiler();
         $this->registerEngineResolver();
+
+        $this->app->terminating(static function () {
+            Component::flushCache();
+        });
     }
 
     /**
@@ -48,6 +52,10 @@ public function registerFactory()
 
             $factory->share('app', $app);
 
+            $app->terminating(static function () {
+                Component::forgetFactory();
+            });
+
             return $factory;
         });
     }
@@ -153,7 +161,13 @@ public function registerPhpEngine($resolver)
     public function registerBladeEngine($resolver)
     {
         $resolver->register('blade', function () {
-            return new CompilerEngine($this->app['blade.compiler'], $this->app['files']);
+            $compiler = new CompilerEngine($this->app['blade.compiler'], $this->app['files']);
+
+            $this->app->terminating(static function () use ($compiler) {
+                $compiler->forgetCompiledOrNotExpired();
+            });
+
+            return $compiler;
         });
     }
 }