FM / View

/home/techb158/ileadtechnology.com/vendor/laravel/framework/src/Illuminate/View/

/home/techb158/ileadtechnology.com/vendor/laravel/framework/src/Illuminate/View

Name	Size	Mode	Actions
Compilers/	-	0755	rm
Concerns/	-	0755	rm
Engines/	-	0755	rm
Middleware/	-	0755	rm
AnonymousComponent.php	999	0644	edit dl rm
Component.php	7179	0644	edit dl rm
ComponentAttributeBag.php	7017	0644	edit dl rm
composer.json	959	0644	edit dl rm
Factory.php	14432	0755	edit dl rm
FileViewFinder.php	7305	0755	edit dl rm
InvokableComponentVariable.php	1995	0644	edit dl rm
LICENSE.md	1075	0644	edit dl rm
View.php	9737	0755	edit dl rm
ViewException.php	898	0644	edit dl rm
ViewFinderInterface.php	1451	0755	edit dl rm
ViewName.php	523	0644	edit dl rm
ViewServiceProvider.php	4389	0755	edit dl rm

Edit: /home/techb158/ileadtechnology.com/vendor/laravel/framework/src/Illuminate/View/Component.php (7179B)

<?php

namespace Illuminate\View;

use Closure;
use Illuminate\Container\Container;
use Illuminate\Support\Str;
use ReflectionClass;
use ReflectionMethod;
use ReflectionProperty;

abstract class Component
{
    /**
     * The cache of public property names, keyed by class.
     *
     * @var array
     */
    protected static $propertyCache = [];

/**
     * The cache of public method names, keyed by class.
     *
     * @var array
     */
    protected static $methodCache = [];

/**
     * The properties / methods that should not be exposed to the component.
     *
     * @var array
     */
    protected $except = [];

/**
     * The component alias name.
     *
     * @var string
     */
    public $componentName;

/**
     * The component attributes.
     *
     * @var \Illuminate\View\ComponentAttributeBag
     */
    public $attributes;

/**
     * Get the view / view contents that represent the component.
     *
     * @return \Illuminate\View\View|\Closure|string
     */
    abstract public function render();

/**
     * Resolve the Blade view or view file that should be used when rendering the component.
     *
     * @return \Illuminate\View\View|\Closure|string
     */
    public function resolveView()
    {
        $view = $this->render();

if ($view instanceof View) {
            return $view;
        }

$resolver = function ($view) {
            $factory = Container::getInstance()->make('view');

return $factory->exists($view)
                        ? $view
                        : $this->createBladeViewFromString($factory, $view);
        };

return $view instanceof Closure ? function (array $data = []) use ($view, $resolver) {
            return $resolver($view($data));
        }
        : $resolver($view);
    }

/**
     * 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)
    {
        $factory->addNamespace(
            '__components',
            $directory = Container::getInstance()['config']->get('view.compiled')
        );

if (! file_exists($viewFile = $directory.'/'.sha1($contents).'.blade.php')) {
            if (! is_dir($directory)) {
                mkdir($directory, 0755, true);
            }

file_put_contents($viewFile, $contents);
        }

return '__components::'.basename($viewFile, '.blade.php');
    }

/**
     * Get the data that should be supplied to the view.
     *
     * @author Freek Van der Herten
     * @author Brent Roose
     *
     * @return array
     */
    public function data()
    {
        $this->attributes = $this->attributes ?: new ComponentAttributeBag;

return array_merge($this->extractPublicProperties(), $this->extractPublicMethods());
    }

/**
     * Extract the public properties for the component.
     *
     * @return array
     */
    protected function extractPublicProperties()
    {
        $class = get_class($this);

if (! isset(static::$propertyCache[$class])) {
            $reflection = new ReflectionClass($this);

static::$propertyCache[$class] = collect($reflection->getProperties(ReflectionProperty::IS_PUBLIC))
                ->reject(function (ReflectionProperty $property) {
                    return $property->isStatic();
                })
                ->reject(function (ReflectionProperty $property) {
                    return $this->shouldIgnore($property->getName());
                })
                ->map(function (ReflectionProperty $property) {
                    return $property->getName();
                })->all();
        }

$values = [];

foreach (static::$propertyCache[$class] as $property) {
            $values[$property] = $this->{$property};
        }

return $values;
    }

/**
     * Extract the public methods for the component.
     *
     * @return array
     */
    protected function extractPublicMethods()
    {
        $class = get_class($this);

if (! isset(static::$methodCache[$class])) {
            $reflection = new ReflectionClass($this);

static::$methodCache[$class] = collect($reflection->getMethods(ReflectionMethod::IS_PUBLIC))
                ->reject(function (ReflectionMethod $method) {
                    return $this->shouldIgnore($method->getName());
                })
                ->map(function (ReflectionMethod $method) {
                    return $method->getName();
                });
        }

$values = [];

foreach (static::$methodCache[$class] as $method) {
            $values[$method] = $this->createVariableFromMethod(new ReflectionMethod($this, $method));
        }

return $values;
    }

/**
     * Create a callable variable from the given method.
     *
     * @param  \ReflectionMethod  $method
     * @return mixed
     */
    protected function createVariableFromMethod(ReflectionMethod $method)
    {
        return $method->getNumberOfParameters() === 0
                        ? $this->createInvokableVariable($method->getName())
                        : Closure::fromCallable([$this, $method->getName()]);
    }

/**
     * Create an invokable, toStringable variable for the given component method.
     *
     * @param  string  $method
     * @return \Illuminate\View\InvokableComponentVariable
     */
    protected function createInvokableVariable(string $method)
    {
        return new InvokableComponentVariable(function () use ($method) {
            return $this->{$method}();
        });
    }

/**
     * Determine if the given property / method should be ignored.
     *
     * @param  string  $name
     * @return bool
     */
    protected function shouldIgnore($name)
    {
        return Str::startsWith($name, '__') ||
               in_array($name, $this->ignoredMethods());
    }

/**
     * Get the methods that should be ignored.
     *
     * @return array
     */
    protected function ignoredMethods()
    {
        return array_merge([
            'data',
            'render',
            'resolveView',
            'shouldRender',
            'view',
            'withName',
            'withAttributes',
        ], $this->except);
    }

/**
     * Set the component alias name.
     *
     * @param  string  $name
     * @return $this
     */
    public function withName($name)
    {
        $this->componentName = $name;

return $this;
    }

/**
     * Set the extra attributes that the component should make available.
     *
     * @param  array  $attributes
     * @return $this
     */
    public function withAttributes(array $attributes)
    {
        $this->attributes = $this->attributes ?: new ComponentAttributeBag;

$this->attributes->setAttributes($attributes);

return $this;
    }

/**
     * Determine if the component should be rendered.
     *
     * @return bool
     */
    public function shouldRender()
    {
        return true;
    }
}

cmd: