cs\Page\Includes

Complexity

Total Complexity

126

Size/Duplication

Total Lines	833
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	4
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	init_includes()	0	11	1
A	html()	0	3	1
C	html_internal()	0	27	7
A	js()	0	3	1
C	js_internal()	0	26	7
A	css()	0	3	1
C	css_internal()	0	28	7
A	config()	0	3	1
A	config_internal()	0	16	2
B	add_includes_on_page()	0	40	5
A	webcomponents_polyfill()	0	17	4
B	add_system_configs()	0	29	3
C	get_includes_for_page_with_compression()	0	31	8
B	get_includes_for_page_without_compression()	0	23	6
A	get_includes_prepare()	0	23	3
B	get_includes_is_dependency()	0	12	6
A	absolute_path_to_relative()	0	3	1
A	add_versions_hash()	0	12	3
C	add_includes_on_page_manually_added()	0	22	7
B	get_includes_list()	0	23	4
A	get_includes_list_add_includes()	0	5	1
A	get_includes_list_add_includes_internal()	0	3	2
A	rebuild_cache()	0	17	2
A	ie_edge()	0	9	2
A	create_cached_includes_files()	0	9	2
B	create_cached_includes_files_process_files()	0	37	6
B	includes_dependencies_and_map()	0	47	4
B	process_meta()	0	41	6
A	process_map()	0	6	2
B	process_map_internal()	0	27	5
C	normalize_dependencies()	0	49	12
A	clean_includes_arrays_without_files()	0	11	4

<?php
/**
 * @package   CleverStyle CMS
 * @author    Nazar Mokrynskyi <nazar@mokrynskyi.com>
 * @copyright Copyright (c) 2014-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs\Page;
use
	cs\App,
	cs\Core,
	cs\Config,
	cs\Event,
	cs\Language,
	cs\Request,
	cs\User,
	h,
	cs\Page\Includes\RequireJS;

/**
 * Includes management for `cs\Page` class
 *
 * @property string $Title
 * @property string $Description
 * @property string $canonical_url
 * @property string $Head
 * @property string $post_Body
 * @property string $theme
 */
trait Includes {
	use
		RequireJS;
	/**
	 * @var array[]
	 */
	protected $core_html;
	/**
	 * @var array[]
	 */
	protected $core_js;
	/**
	 * @var array[]
	 */
	protected $core_css;
	/**
	 * @var string
	 */
	protected $core_config;
	/**
	 * @var array[]
	 */
	protected $html;
	/**
	 * @var array[]
	 */
	protected $js;
	/**
	 * @var array[]
	 */
	protected $css;
	/**
	 * @var string
	 */
	protected $config;
	/**
	 * Base name is used as prefix when creating CSS/JS/HTML cache files in order to avoid collisions when having several themes and languages
	 * @var string
	 */
	protected $pcache_basename;
	protected function init_includes () {
		$this->core_html       = [0 => [], 1 => []];
		$this->core_js         = [0 => [], 1 => []];
		$this->core_css        = [0 => [], 1 => []];
		$this->core_config     = '';
		$this->html            = [0 => [], 1 => []];
		$this->js              = [0 => [], 1 => []];
		$this->css             = [0 => [], 1 => []];
		$this->config          = '';
		$this->pcache_basename = '';
	}
	/**
	 * Including of Web Components
	 *
	 * @param string|string[] $add  Path to including file, or code
	 * @param string          $mode Can be <b>file</b> or <b>code</b>
	 *
	 * @return \cs\Page
	 */
	function html ($add, $mode = 'file') {
		return $this->html_internal($add, $mode);
	}
	/**
	 * @param string|string[] $add
	 * @param string          $mode
	 * @param bool            $core
	 *
	 * @return \cs\Page
	 */
	protected function html_internal ($add, $mode = 'file', $core = false) {
		if (!$add) {
			return $this;
		}
		if (is_array($add)) {
			foreach (array_filter($add) as $script) {
				$this->html_internal($script, $mode, $core);
			}
		} else {
			if ($core) {
				$html = &$this->core_html;
			} else {
				$html = &$this->html;
			}
			if ($mode == 'file') {
				$html[0][] = h::link(
					[
						'href' => $add,
						'rel'  => 'import'
					]
				);
			} elseif ($mode == 'code') {
				$html[1][] = "$add\n";
			}
		}
		return $this;
	}
	/**
	 * Including of JavaScript
	 *
	 * @param string|string[] $add  Path to including file, or code
	 * @param string          $mode Can be <b>file</b> or <b>code</b>
	 *
	 * @return \cs\Page
	 */
	function js ($add, $mode = 'file') {
		return $this->js_internal($add, $mode);
	}
	/**
	 * @param string|string[] $add
	 * @param string          $mode
	 * @param bool            $core
	 *
	 * @return \cs\Page
	 */
	protected function js_internal ($add, $mode = 'file', $core = false) {
		if (!$add) {
			return $this;
		}
		if (is_array($add)) {
			foreach (array_filter($add) as $script) {
				$this->js_internal($script, $mode, $core);
			}
		} else {
			if ($core) {
				$js = &$this->core_js;
			} else {
				$js = &$this->js;
			}
			if ($mode == 'file') {
				$js[0][] = h::script(
					[
						'src' => $add
					]
				);
			} elseif ($mode == 'code') {
				$js[1][] = "$add\n";
			}
		}
		return $this;
	}
	/**
	 * Including of CSS
	 *
	 * @param string|string[] $add  Path to including file, or code
	 * @param string          $mode Can be <b>file</b> or <b>code</b>
	 *
	 * @return \cs\Page
	 */
	function css ($add, $mode = 'file') {
		return $this->css_internal($add, $mode);
	}
	/**
	 * @param string|string[] $add
	 * @param string          $mode
	 * @param bool            $core
	 *
	 * @return \cs\Page
	 */
	protected function css_internal ($add, $mode = 'file', $core = false) {
		if (!$add) {
			return $this;
		}
		if (is_array($add)) {
			foreach (array_filter($add) as $style) {
				$this->css_internal($style, $mode, $core);
			}
		} else {
			if ($core) {
				$css = &$this->core_css;
			} else {
				$css = &$this->css;
			}
			if ($mode == 'file') {
				$css[0][] = h::link(
					[
						'href'           => $add,
						'rel'            => 'stylesheet',
						'shim-shadowdom' => true
					]
				);
			} elseif ($mode == 'code') {
				$css[1][] = "$add\n";
			}
		}
		return $this;
	}
	/**
	 * Add config on page to make it available on frontend
	 *
	 * @param mixed  $config_structure        Any scalar type or array
	 * @param string $target                  Target is property of `window` object where config will be inserted as value, nested properties like `cs.sub.prop`
	 *                                        are supported and all nested properties are created on demand. It is recommended to use sub-properties of `cs`
	 *
	 * @return \cs\Page
	 */
	function config ($config_structure, $target) {
		return $this->config_internal($config_structure, $target);
	}
	/**
	 * @param mixed  $config_structure
	 * @param string $target
	 * @param bool   $core
	 *
	 * @return \cs\Page
	 */
	protected function config_internal ($config_structure, $target, $core = false) {
		$config = h::script(
			json_encode($config_structure, JSON_UNESCAPED_UNICODE),
			[
				'target' => $target,
				'class'  => 'cs-config',
				'type'   => 'application/json'
			]
		);
		if ($core) {
			$this->core_config .= $config;
		} else {
			$this->config .= $config;
		}
		return $this;
	}
	/**
	 * Getting of HTML, JS and CSS includes
	 *
	 * @return \cs\Page
	 */
	protected function add_includes_on_page () {
		$Config = Config::instance(true);
		if (!$Config) {
			return $this;
		}
		/**
		 * Base name for cache files
		 */
		$this->pcache_basename = "_{$this->theme}_".Language::instance()->clang;
		/**
		 * Some JS configs required by system
		 */
		$this->add_system_configs();
		// TODO: I hope some day we'll get rid of this sh*t :(
		$this->ie_edge();
		$Request = Request::instance();
		/**
		 * If CSS and JavaScript compression enabled
		 */
		if ($Config->core['cache_compress_js_css'] && !($Request->admin_path && isset($Request->query['debug']))) {
			$this->webcomponents_polyfill($Request, true);
			$includes = $this->get_includes_for_page_with_compression();
		} else {
			$this->webcomponents_polyfill($Request, false);
			/**
			 * Language translation is added explicitly only when compression is disabled, otherwise it will be in compressed JS file
			 */
			/**
			 * @var \cs\Page $this
			 */
			$this->config_internal(Language::instance(), 'cs.Language', true);
			$this->config_internal($this->get_requirejs_paths(), 'requirejs.paths', true);
			$includes = $this->get_includes_for_page_without_compression($Config);
		}
		$this->css_internal($includes['css'], 'file', true);
		$this->js_internal($includes['js'], 'file', true);
		$this->html_internal($includes['html'], 'file', true);
		$this->add_includes_on_page_manually_added($Config);
		return $this;
	}
	/**
	 * @param string[] $path
	 *
	 * @return string[]
	 */
	protected function absolute_path_to_relative ($path) {
		return _substr($path, strlen(DIR) + 1);
	}
	/**
	 * Add JS polyfills for IE/Edge
	 */
	protected function ie_edge () {
		if (preg_match('/Trident|Edge/', Request::instance()->header('user-agent'))) {
			$this->js_internal(
				get_files_list(DIR."/includes/js/microsoft_sh*t", "/.*\\.js$/i", 'f', "includes/js/microsoft_sh*t", true),
				'file',
				true
			);
		}
	}
	/**
	 * Hack: Add WebComponents Polyfill for browsers without native Shadow DOM support
	 *
	 * @param Request $Request
	 * @param bool    $with_compression
	 */
	protected function webcomponents_polyfill ($Request, $with_compression) {
		if ($Request->cookie('shadow_dom') != 1) {
			$file = 'includes/js/WebComponents-polyfill/webcomponents-custom.min.js';
			if ($with_compression) {
				$compressed_file = PUBLIC_CACHE.'/webcomponents.js';
				if (!file_exists($compressed_file)) {
					$content = file_get_contents(DIR."/$file");
					file_put_contents($compressed_file, gzencode($content, 9), LOCK_EX | FILE_BINARY);
					file_put_contents("$compressed_file.hash", substr(md5($content), 0, 5));
				}
				$hash = file_get_contents("$compressed_file.hash");
				$this->js_internal("storage/pcache/webcomponents.js?$hash", 'file', true);
			} else {
				$this->js_internal($file, 'file', true);
			}
		}
	}
	protected function add_system_configs () {
		$Config         = Config::instance();
		$Request        = Request::instance();
		$User           = User::instance();
		$current_module = $Request->current_module;
		$this->config_internal(
			[
				'base_url'              => $Config->base_url(),
				'current_base_url'      => $Config->base_url().'/'.($Request->admin_path ? 'admin/' : '').$current_module,
				'public_key'            => Core::instance()->public_key,
				'module'                => $current_module,
				'in_admin'              => (int)$Request->admin_path,
				'is_admin'              => (int)$User->admin(),
				'is_user'               => (int)$User->user(),
				'is_guest'              => (int)$User->guest(),
				'password_min_length'   => (int)$Config->core['password_min_length'],
				'password_min_strength' => (int)$Config->core['password_min_strength'],
				'debug'                 => (int)DEBUG,
				'route'                 => $Request->route,
				'route_path'            => $Request->route_path,
				'route_ids'             => $Request->route_ids
			],
			'cs',
			true
		);
		if ($User->admin()) {
			$this->config_internal((int)$Config->core['simple_admin_mode'], 'cs.simple_admin_mode', true);
		}
	}
	/**
	 * @return array[]
	 */
	protected function get_includes_for_page_with_compression () {
		/**
		 * Rebuild cache if necessary
		 */
		if (!file_exists(PUBLIC_CACHE."/$this->pcache_basename.json")) {
			$this->rebuild_cache();
		}
		list($dependencies, $structure) = file_get_json(PUBLIC_CACHE."/$this->pcache_basename.json");
		$system_includes = [
			'css'  => ["storage/pcache/$this->pcache_basename.css?{$structure['']['css']}"],
			'js'   => ["storage/pcache/$this->pcache_basename.js?{$structure['']['js']}"],
			'html' => ["storage/pcache/$this->pcache_basename.html?{$structure['']['html']}"]
		];
		list($includes, $dependencies_includes, $dependencies, $current_url) = $this->get_includes_prepare($dependencies, '+');
		foreach ($structure as $filename_prefix => $hashes) {
			if (!$filename_prefix) {
				continue;
			}
			$is_dependency = $this->get_includes_is_dependency($dependencies, $filename_prefix, '+');
			if ($is_dependency || mb_strpos($current_url, $filename_prefix) === 0) {
				foreach ($hashes as $extension => $hash) {
					if ($is_dependency) {
						$dependencies_includes[$extension][] = "storage/pcache/$filename_prefix$this->pcache_basename.$extension?$hash";
					} else {
						$includes[$extension][] = "storage/pcache/$filename_prefix$this->pcache_basename.$extension?$hash";
					}
				}
			}
		}
		return array_merge_recursive($system_includes, $dependencies_includes, $includes);
	}
	/**
	 * @param Config $Config
	 *
	 * @return array[]
	 */
	protected function get_includes_for_page_without_compression ($Config) {
		// To determine all dependencies and stuff we need `$Config` object to be already created
		if ($Config) {
			list($dependencies, $includes_map) = $this->includes_dependencies_and_map();
			$system_includes = $includes_map[''];
			list($includes, $dependencies_includes, $dependencies, $current_url) = $this->get_includes_prepare($dependencies, '/');
			foreach ($includes_map as $url => $local_includes) {
				if (!$url) {
					continue;
				}
				$is_dependency = $this->get_includes_is_dependency($dependencies, $url, '/');
				if ($is_dependency) {
					$dependencies_includes = array_merge_recursive($dependencies_includes, $local_includes);
				} elseif (mb_strpos($current_url, $url) === 0) {
					$includes = array_merge_recursive($includes, $local_includes);
				}
			}
			$includes = array_merge_recursive($system_includes, $dependencies_includes, $includes);
		} else {
			$includes = $this->get_includes_list();
		}
		return $this->add_versions_hash($this->absolute_path_to_relative($includes));
	}
	/**
	 * @param array  $dependencies
	 * @param string $separator `+` or `/`
	 *
	 * @return array
	 */
	protected function get_includes_prepare ($dependencies, $separator) {
		$Request               = Request::instance();
		$includes              = [
			'css'  => [],
			'js'   => [],
			'html' => []
		];
		$dependencies_includes = $includes;
		$current_module        = $Request->current_module;
		/**
		 * Current URL based on controller path (it better represents how page was rendered)
		 */
		$current_url = array_slice(App::instance()->controller_path, 1);
		$current_url = ($Request->admin_path ? "admin$separator" : '')."$current_module$separator".implode($separator, $current_url);
		/**
		 * Narrow the dependencies to current module only
		 */
		$dependencies = array_merge(
			isset($dependencies[$current_module]) ? $dependencies[$current_module] : [],
			$dependencies['System']
		);
		return [$includes, $dependencies_includes, $dependencies, $current_url];
	}
	/**
	 * @param array  $dependencies
	 * @param string $url
	 * @param string $separator `+` or `/`
	 *
	 * @return bool
	 */
	protected function get_includes_is_dependency ($dependencies, $url, $separator) {
		$url_exploded = explode($separator, $url);
		/** @noinspection NestedTernaryOperatorInspection */
		$url_module = $url_exploded[0] != 'admin' ? $url_exploded[0] : (@$url_exploded[1] ?: '');
		$Request    = Request::instance();
		return
			$url_module !== Config::SYSTEM_MODULE &&
			in_array($url_module, $dependencies) &&
			(
				$Request->admin_path || $Request->admin_path == ($url_exploded[0] == 'admin')
			);
	}
	protected function add_versions_hash ($includes) {
		$content = array_map('file_get_contents', get_files_list(DIR.'/components', '/^meta\.json$/', 'f', true, true));
		$content = implode('', $content);
		$hash    = substr(md5($content), 0, 5);
		foreach ($includes as &$files) {
			foreach ($files as &$file) {
				$file .= "?$hash";
			}
			unset($file);
		}
		return $includes;
	}
	/**
	 * @param Config $Config
	 */
	protected function add_includes_on_page_manually_added ($Config) {
		foreach (['core_html', 'core_js', 'core_css', 'html', 'js', 'css'] as $type) {
			foreach ($this->$type as &$elements) {
				$elements = implode('', array_unique($elements));
			}
			unset($elements);
		}
		$this->Head .=
			$this->core_config.
			$this->config.
			$this->core_css[0].$this->css[0].
			h::style($this->core_css[1].$this->css[1] ?: false);
		$js_html_insert_to = $Config->core['put_js_after_body'] ? 'post_Body' : 'Head';
		$js_html           =
			$this->core_js[0].
			h::script($this->core_js[1] ?: false).
			$this->js[0].
			h::script($this->js[1] ?: false).
			$this->core_html[0].$this->html[0].
			$this->core_html[1].$this->html[1];
		$this->$js_html_insert_to .= $js_html;
	}
	/**
	 * Getting of HTML, JS and CSS files list to be included
	 *
	 * @return string[][]
	 */
	protected function get_includes_list () {
		$includes = [];
		/**
		 * Get includes of system and theme
		 */
		$this->get_includes_list_add_includes(DIR.'/includes', $includes);
		$this->get_includes_list_add_includes(THEMES."/$this->theme", $includes);
		$Config = Config::instance();
		foreach ($Config->components['modules'] as $module_name => $module_data) {
			if ($module_data['active'] == Config\Module_Properties::UNINSTALLED) {
				continue;
			}
			$this->get_includes_list_add_includes(MODULES."/$module_name/includes", $includes);
		}
		foreach ($Config->components['plugins'] as $plugin_name) {
			$this->get_includes_list_add_includes(PLUGINS."/$plugin_name/includes", $includes);
		}
		return [
			'html' => array_merge(...$includes['html']),
			'js'   => array_merge(...$includes['js']),
			'css'  => array_merge(...$includes['css'])
		];
	}
	/**
	 * @param string     $base_dir
	 * @param string[][] $includes
	 */
	protected function get_includes_list_add_includes ($base_dir, &$includes) {
		$includes['html'][] = $this->get_includes_list_add_includes_internal($base_dir, 'html');
		$includes['js'][]   = $this->get_includes_list_add_includes_internal($base_dir, 'js');
		$includes['css'][]  = $this->get_includes_list_add_includes_internal($base_dir, 'css');
	}
	/**
	 * @param string $base_dir
	 * @param string $ext
	 *
	 * @return array
	 */
	protected function get_includes_list_add_includes_internal ($base_dir, $ext) {
		return get_files_list("$base_dir/$ext", "/.*\\.$ext\$/i", 'f', true, true, 'name', '!include') ?: [];
	}
	/**
	 * Rebuilding of HTML, JS and CSS cache
	 *
	 * @return \cs\Page
	 */
	protected function rebuild_cache () {
		list($dependencies, $includes_map) = $this->includes_dependencies_and_map();
		$structure = [];
		foreach ($includes_map as $filename_prefix => $includes) {
			// We replace `/` by `+` to make it suitable for filename
			$filename_prefix             = str_replace('/', '+', $filename_prefix);
			$structure[$filename_prefix] = $this->create_cached_includes_files($filename_prefix, $includes);
		}
		unset($includes_map, $filename_prefix, $includes);
		file_put_json(
			PUBLIC_CACHE."/$this->pcache_basename.json",
			[$dependencies, $structure]
		);
		unset($structure);
		Event::instance()->fire('System/Page/rebuild_cache');
		return $this;
	}
	/**
	 * Creates cached version of given HTML, JS and CSS files.
	 * Resulting file name consists of <b>$filename_prefix</b> and <b>$this->pcache_basename</b>
	 *
	 * @param string $filename_prefix
	 * @param array  $includes Array of paths to files, may have keys: <b>css</b> and/or <b>js</b> and/or <b>html</b>
	 *
	 * @return array
	 */
	protected function create_cached_includes_files ($filename_prefix, $includes) {
		$cache_hash = [];
		foreach ($includes as $extension => $files) {
			$content = $this->create_cached_includes_files_process_files($extension, $filename_prefix, $files);
			file_put_contents(PUBLIC_CACHE."/$filename_prefix$this->pcache_basename.$extension", gzencode($content, 9), LOCK_EX | FILE_BINARY);
			$cache_hash[$extension] = substr(md5($content), 0, 5);
		}
		return $cache_hash;
	}
	protected function create_cached_includes_files_process_files ($extension, $filename_prefix, $files) {
		$content = '';
		switch ($extension) {
			/**
			 * Insert external elements into resulting css file.
			 * It is needed, because those files will not be copied into new destination of resulting css file.
			 */
			case 'css':
				$callback = function ($content, $file) {
					return $content.Includes_processing::css(file_get_contents($file), $file);
				};
				break;
			/**
			 * Combine css and js files for Web Component into resulting files in order to optimize loading process
			 */
			case 'html':
				/**
				 * For CSP-compatible HTML files we need to know destination to put there additional JS/CSS files
				 */
				$destination = Config::instance()->core['vulcanization'] ? false : PUBLIC_CACHE;
				$callback    = function ($content, $file) use ($filename_prefix, $destination) {
					$base_filename = "$filename_prefix$this->pcache_basename-".basename($file).'+'.substr(md5($file), 0, 5);
					return $content.Includes_processing::html(file_get_contents($file), $file, $base_filename, $destination);
				};
				break;
			case 'js':
				$callback = function ($content, $file) {
					return $content.Includes_processing::js(file_get_contents($file));
				};
				if ($filename_prefix == '') {
					$content = 'window.cs={Language:'._json_encode(Language::instance()).'};';
					$content .= 'window.requirejs={paths:'._json_encode($this->get_requirejs_paths()).'};';
				}
		}
		/** @noinspection PhpUndefinedVariableInspection */
		return array_reduce($files, $callback, $content);
	}
	/**
	 * Get dependencies of components between each other (only that contains some HTML, JS and CSS files) and mapping HTML, JS and CSS files to URL paths
	 *
	 * @return array[] [$dependencies, $includes_map]
	 */
	protected function includes_dependencies_and_map () {
		/**
		 * Get all includes
		 */
		$all_includes = $this->get_includes_list();
		$includes_map = [];
		/**
		 * Array [package => [list of packages it depends on]]
		 */
		$dependencies    = [];
		$functionalities = [];
		/**
		 * According to components's maps some files should be included only on specific pages.
		 * Here we read this rules, and remove from whole includes list such items, that should be included only on specific pages.
		 * Also collect dependencies.
		 */
		$Config = Config::instance();
		foreach ($Config->components['modules'] as $module_name => $module_data) {
			if ($module_data['active'] == Config\Module_Properties::UNINSTALLED) {
				continue;
			}
			$this->process_meta(MODULES."/$module_name", $dependencies, $functionalities);
			$this->process_map(MODULES."/$module_name", $includes_map, $all_includes);
		}
		unset($module_name, $module_data);
		foreach ($Config->components['plugins'] as $plugin_name) {
			$this->process_meta(PLUGINS."/$plugin_name", $dependencies, $functionalities);
			$this->process_map(PLUGINS."/$plugin_name", $includes_map, $all_includes);
		}
		unset($plugin_name);
		/**
		 * For consistency
		 */
		$includes_map[''] = $all_includes;
		Event::instance()->fire(
			'System/Page/includes_dependencies_and_map',
			[
				'dependencies' => &$dependencies,
				'includes_map' => &$includes_map
			]
		);
		$dependencies = $this->normalize_dependencies($dependencies, $functionalities);
		$includes_map = $this->clean_includes_arrays_without_files($dependencies, $includes_map);
		$dependencies = array_map('array_values', $dependencies);
		$dependencies = array_filter($dependencies);
		return [$dependencies, $includes_map];
	}
	/**
	 * Process meta information and corresponding entries to dependencies and functionalities
	 *
	 * @param string $base_dir
	 * @param array  $dependencies
	 * @param array  $functionalities
	 */
	protected function process_meta ($base_dir, &$dependencies, &$functionalities) {
		if (!file_exists("$base_dir/meta.json")) {
			return;
		}
		$meta = file_get_json("$base_dir/meta.json");
		$meta += [
			'require'  => [],
			'optional' => [],
			'provide'  => []
		];
		$package = $meta['package'];
		foreach ((array)$meta['require'] as $r) {
			/**
			 * Get only name of package or functionality
			 */
			$r                        = preg_split('/[=<>]/', $r, 2)[0];
			$dependencies[$package][] = $r;
		}
		foreach ((array)$meta['optional'] as $o) {
			/**
			 * Get only name of package or functionality
			 */
			$o                        = preg_split('/[=<>]/', $o, 2)[0];
			$dependencies[$package][] = $o;
		}
		foreach ((array)$meta['provide'] as $p) {
			/**
			 * If provides sub-functionality for other component (for instance, `Blog/post_patch`) - inverse "providing" to "dependency"
			 * Otherwise it is just functionality alias to package name
			 */
			if (strpos($p, '/') !== false) {
				/**
				 * Get name of package or functionality
				 */
				$p                  = explode('/', $p)[0];
				$dependencies[$p][] = $package;
			} else {
				$functionalities[$p] = $package;
			}
		}
	}
	/**
	 * Process map structure, fill includes map and remove files from list of all includes (remaining files will be included on all pages)
	 *
	 * @param string $base_dir
	 * @param array  $includes_map
	 * @param array  $all_includes
	 */
	protected function process_map ($base_dir, &$includes_map, &$all_includes) {
		if (!file_exists("$base_dir/includes/map.json")) {
			return;
		}
		$this->process_map_internal(file_get_json("$base_dir/includes/map.json"), "$base_dir/includes", $includes_map, $all_includes);
	}
	/**
	 * Process map structure, fill includes map and remove files from list of all includes (remaining files will be included on all pages)
	 *
	 * @param array  $map
	 * @param string $includes_dir
	 * @param array  $includes_map
	 * @param array  $all_includes
	 */
	protected function process_map_internal ($map, $includes_dir, &$includes_map, &$all_includes) {
		foreach ($map as $path => $files) {
			foreach ((array)$files as $file) {
				$extension = file_extension($file);
				if (in_array($extension, ['css', 'js', 'html'])) {
					$file                              = "$includes_dir/$extension/$file";
					$includes_map[$path][$extension][] = $file;
					$all_includes[$extension]          = array_diff($all_includes[$extension], [$file]);
				} else {
					$file = rtrim($file, '*');
					/**
					 * Wildcard support, it is possible to specify just path prefix and all files with this prefix will be included
					 */
					$found_files = array_filter(
						get_files_list($includes_dir, '/.*\.(css|js|html)$/i', 'f', '', true, 'name', '!include') ?: [],
						function ($f) use ($file) {
							// We need only files with specified mask and only those located in directory that corresponds to file's extension
							return preg_match("#^(css|js|html)/$file.*\\1$#i", $f);
						}
					);
					// Drop first level directory
					$found_files = _preg_replace('#^[^/]+/(.*)#', '$1', $found_files);
					$this->process_map_internal([$path => $found_files], $includes_dir, $includes_map, $all_includes);
				}
			}
		}
	}
	/**
	 * Replace functionalities by real packages names, take into account recursive dependencies
	 *
	 * @param array $dependencies
	 * @param array $functionalities
	 *
	 * @return array
	 */
	protected function normalize_dependencies ($dependencies, $functionalities) {
		/**
		 * First of all remove packages without any dependencies
		 */
		$dependencies = array_filter($dependencies);
		/**
		 * First round, process aliases among keys
		 */
		foreach (array_keys($dependencies) as $d) {
			if (isset($functionalities[$d])) {
				$package = $functionalities[$d];
				/**
				 * Add dependencies to existing package dependencies
				 */
				foreach ($dependencies[$d] as $dependency) {
					$dependencies[$package][] = $dependency;
				}
				/**
				 * Drop alias
				 */
				unset($dependencies[$d]);
			}
		}
		unset($d, $dependency);
		/**
		 * Second round, process aliases among dependencies
		 */
		foreach ($dependencies as &$depends_on) {
			foreach ($depends_on as &$dependency) {
				if (isset($functionalities[$dependency])) {
					$dependency = $functionalities[$dependency];
				}
			}
		}
		unset($depends_on, $dependency);
		/**
		 * Third round, process recursive dependencies
		 */
		foreach ($dependencies as &$depends_on) {
			foreach ($depends_on as &$dependency) {
				if ($dependency != 'System' && isset($dependencies[$dependency])) {
					foreach (array_diff($dependencies[$dependency], $depends_on) as $new_dependency) {
						$depends_on[] = $new_dependency;
					}
				}
			}
		}
		return array_map('array_unique', $dependencies);
	}
	/**
	 * Includes array is composed from dependencies and sometimes dependencies doesn't have any files, so we'll clean that
	 *
	 * @param array $dependencies
	 * @param array $includes_map
	 *
	 * @return array
	 */
	protected function clean_includes_arrays_without_files ($dependencies, $includes_map) {
		foreach ($dependencies as &$depends_on) {
			foreach ($depends_on as $index => &$dependency) {
				if (!isset($includes_map[$dependency])) {
					unset($depends_on[$index]);
				}
			}
			unset($dependency);
		}
		return $includes_map;
	}
}