87 
            ->setData($viewModel->cut('content'));
88 

89 
        return view('explore', [
90 
            'heading' => translate('Explore:') . ' <u>' . $title . '</u> ' . translate(($type == 'movie' ? 'Movies' : 'TV Series')),
91 
            'paginator' => $pagination
92 
        ]);
93 
    }
94 

95 
    public function people($slug)
96 
    {
97 
        $cache  = cache('tmdb.home');
98 
        $client = TmdbClient::create('movie');
99 
        $result = $client->request('person/' . substr($slug, strrpos($slug, '-') + 1), ['append_to_response' => 'combined_credits']);;
100 

101 
        $viewModel = new TmdbCollection(
102 
            new GenreCollection(
103 
                $cache->load('movie.genres', fn () => $client->getGenre())
104 
            ),
105 
            [
106 
                'movie' => array_filter($result['combined_credits']['cast'] ?? [], fn ($media) => $media['media_type'] == 'movie'),
107 
            ]
108 
        );
109 

110 
        $client->setType('tv');
111 

112 
        $viewModel->setGenreCollection(

                                

                                    
68 
            (is_string($callback) && function_exists($callback))
69 
            || (is_object($callback) && ($callback instanceof Closure))
70 
        )
71 
            || (is_array($callback) && method_exists($callback[0], $callback[1]));
72 
    }
73 

74 
    public static function load($callback, ...$params)
75 
    {
76 
        if (!self::exists($callback)) {
77 
            throw new UndefinedMethod((is_array($callback) ? (!is_string($callback[0]) ? get_class($callback[0]) : (string) $callback[0]) . '->' . $callback[1] : $callback) . '() does not exists');
78 
        }
79 

80 
        return call_user_func($callback, ...array_values($params));
81 
    }
82 

83 
    public static function create(string $class, ...$args)
84 
    {
85 
        if (!class_exists($class)) {
86 
            throw new UndefinedClass('Class: ' . $class . ' does not exists');
87 
        }
88 

89 
        return new $class(...array_values($args));
90 
    }
91 

92 
    public static function name($callback): string
93 
    {

                                

                                    
106 

107 
            // set new callback method
108 
            $route->setCallback([$route->getCallback()[0], $call_method]);
109 
        }
110 

111 
        // escape grouped/nested named parameter
112 
        $route->setParameters($this->escapeNestedParameters($route->getParameters()));
113 

114 
        // trigger route middleware event
115 
        $this->triggerEvent(IRoute::EVENTS['callback'], $route);
116 

117 
        // load router callback
118 
        return CallbackHandler::load(
119 
            $route->getCallback(),
120 
            ...CallbackHandler::reflect(
121 
                $route->getParameters(),
122 
                $route->getCallback(),
123 
                array_merge($this->getReflectionParameters(), [$route])
124 
            )
125 
        );
126 
    }
127 

128 
    public function callMiddlewares($middlewares): void
129 
    {
130 
        foreach ((array) $middlewares as $middleware) {
131 
            $class = CallbackHandler::create($middleware);

                                

                                    
90 
                // utilize method required paramiters
91 
                $route->setParameters(
92 
                    $this->applyFilters(self::FILTER['parameters'], $this->utilizeRouteParam($matches, $route))
93 
                );
94 

95 
                // set Url to route
96 
                $route->setUrl($url);
97 

98 
                // create route dispatcher
99 
                $dispatcher = new RouteDispatcher($this);
100 

101 
                // dispatch route callback
102 
                return $dispatcher->dispatch($route);
103 
            }
104 
        }
105 

106 
        // call fallback
107 
        if (isset($this->fallback) && CallbackHandler::exists($this->fallback)) {
108 
            CallbackHandler::load($this->fallback);
109 
        }
110 

111 
        // not found any route for this path
112 
        throw new NotFoundException('the route does not matched..');
113 
    }
114 

115 
    /**

                                

                                    
91 
    }
92 

93 
    /**
94 
     * Run The Application
95 
     * @return void
96 
     */
97 
    public static function run(): void
98 
    {
99 
        // load application initial kernels
100 
        self::$app->loadKernels('boot');
101 

102 
        // render router result
103 
        echo self::$app->router->resolve();
104 

105 
        // load application initial kernels
106 
        self::$app->loadKernels('shutdown');
107 
    }
108 

109 
    /**
110 
     * Check Anu Component added to the Application
111 
     * @param string $key 
112 
     * @return bool 
113 
     */
114 
    public static function hasComponent(string $key): bool
115 
    {
116 
        return isset(self::$app->components[$key]);

                                

                                    
14 
    'tmp_dir'   => config('app.tmp_dir'),
15 
    'except'    => ['/admin/*', '/embed/*', '/search/*'],
16 
]);
17 

18 
// serve from cache if production mode
19 
if (!is_dev()) {
20 
    $siteCache->serve();
21 
}
22 

23 
// create a new application instance for this http request
24 
Application::create(__DIR__)
25 
    ->registerKernel(App\Http\Kernels\AppKernel::class)
26 
    ->run();
27 

28 
// stop the application execution process
29 
exit;
30