芝麻web文件管理V1.00
编辑当前文件:/home2/sdektunc/beyondbrightenterprise.com/libraries/src/WebAsset/WebAssetManager.php
<?php /** * Joomla! Content Management System * * @copyright (C) 2019 Open Source Matters, Inc. <https://www.joomla.org> * @license GNU General Public License version 2 or later; see LICENSE.txt */ namespace Joomla\CMS\WebAsset; \defined('JPATH_PLATFORM') or die; use Joomla\CMS\Event\WebAsset\WebAssetRegistryAssetChanged; use Joomla\CMS\WebAsset\Exception\InvalidActionException; use Joomla\CMS\WebAsset\Exception\UnknownAssetException; use Joomla\CMS\WebAsset\Exception\UnsatisfiedDependencyException; /** * Web Asset Manager class * * @method WebAssetManager registerStyle(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager registerAndUseStyle(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager useStyle($name) * @method WebAssetManager disableStyle($name) * @method WebAssetManager addInlineStyle(WebAssetItem|string $content, $options = [], $attributes = [], $dependencies = []) * * @method WebAssetManager registerScript(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager registerAndUseScript(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager useScript($name) * @method WebAssetManager disableScript($name) * @method WebAssetManager addInlineScript(WebAssetItem|string $content, $options = [], $attributes = [], $dependencies = []) * * @method WebAssetManager registerPreset(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager registerAndUsePreset(WebAssetItem|string $asset, string $uri = '', $options = [], $attributes = [], $dependencies = []) * @method WebAssetManager usePreset($name) * @method WebAssetManager disablePreset($name) * * @since 4.0.0 */ class WebAssetManager implements WebAssetManagerInterface { /** * Mark inactive asset * * @var integer * * @since 4.0.0 */ const ASSET_STATE_INACTIVE = 0; /** * Mark active asset. Just enabled, but WITHOUT dependency resolved * * @var integer * * @since 4.0.0 */ const ASSET_STATE_ACTIVE = 1; /** * Mark active asset that is enabled as dependency to another asset * * @var integer * * @since 4.0.0 */ const ASSET_STATE_DEPENDENCY = 2; /** * The WebAsset Registry instance * * @var WebAssetRegistry * * @since 4.0.0 */ protected $registry; /** * A list of active assets (including their dependencies). * Array of Name => State * * @var array * * @since 4.0.0 */ protected $activeAssets = []; /** * Internal marker to check the manager state, * to prevent use of the manager after an assets are rendered * * @var boolean * * @since 4.0.0 */ protected $locked = false; /** * Internal marker to keep track when need to recheck dependencies * * @var boolean * * @since 4.0.0 */ protected $dependenciesIsActual = false; /** * Class constructor * * @param WebAssetRegistry $registry The WebAsset Registry instance * * @since 4.0.0 */ public function __construct(WebAssetRegistry $registry) { $this->registry = $registry; // Listen to changes in the registry $this->registry->getDispatcher()->addListener( 'onWebAssetRegistryChangedAssetOverride', function (WebAssetRegistryAssetChanged $event) { // If the changed asset are used if (!empty($this->activeAssets[$event->getAssetType()][$event->getAsset()->getName()])) { $this->dependenciesIsActual = false; } } ); $this->registry->getDispatcher()->addListener( 'onWebAssetRegistryChangedAssetRemove', function (WebAssetRegistryAssetChanged $event) { // If the changed asset are used if (!empty($this->activeAssets[$event->getAssetType()][$event->getAsset()->getName()])) { $this->dependenciesIsActual = false; } } ); } /** * Get associated registry instance * * @return WebAssetRegistry * * @since 4.0.0 */ public function getRegistry(): WebAssetRegistry { return $this->registry; } /** * Adds support for magic method calls * * @param string $method A method name * @param array $arguments Arguments for a method * * @return mixed * * @throws \BadMethodCallException * * @since 4.0.0 */ public function __call($method, $arguments) { $method = strtolower($method); if (0 === strpos($method, 'use')) { $type = substr($method, 3); if (empty($arguments[0])) { throw new \BadMethodCallException('An asset name is required'); } return $this->useAsset($type, $arguments[0]); } if (0 === strpos($method, 'addinline')) { $type = substr($method, 9); if (empty($arguments[0])) { throw new \BadMethodCallException('Content is required'); } return $this->addInline($type, ...$arguments); } if (0 === strpos($method, 'disable')) { $type = substr($method, 7); if (empty($arguments[0])) { throw new \BadMethodCallException('An asset name is required'); } return $this->disableAsset($type, $arguments[0]); } if (0 === strpos($method, 'register')) { // Check for registerAndUse<Type> $andUse = substr($method, 8, 6) === 'anduse'; // Extract the type $type = $andUse ? substr($method, 14) : substr($method, 8); if (empty($arguments[0])) { throw new \BadMethodCallException('An asset instance or an asset name is required'); } if ($andUse) { $name = $arguments[0] instanceof WebAssetItemInterface ? $arguments[0]->getName() : $arguments[0]; return $this->registerAsset($type, ...$arguments)->useAsset($type, $name); } else { return $this->registerAsset($type, ...$arguments); } } throw new \BadMethodCallException(sprintf('Undefined method %s in class %s', $method, get_class($this))); } /** * Enable an asset item to be attached to a Document * * @param string $type The asset type, script or style * @param string $name The asset name * * @return self * * @throws UnknownAssetException When Asset cannot be found * @throws InvalidActionException When the Manager already attached to a Document * * @since 4.0.0 */ public function useAsset(string $type, string $name): WebAssetManagerInterface { if ($this->locked) { throw new InvalidActionException('WebAssetManager is locked, you came late'); } // Check whether asset exists $asset = $this->registry->get($type, $name); if (empty($this->activeAssets[$type])) { $this->activeAssets[$type] = []; } // For "preset" need to check the dependencies first if ($type === 'preset') { $this->usePresetItems($name); } // Asset already enabled if (!empty($this->activeAssets[$type][$name])) { // Set state to active, in case it was ASSET_STATE_DEPENDENCY $this->activeAssets[$type][$name] = static::ASSET_STATE_ACTIVE; return $this; } $this->activeAssets[$type][$name] = static::ASSET_STATE_ACTIVE; // To re-check dependencies if ($asset->getDependencies()) { $this->dependenciesIsActual = false; } return $this; } /** * Deactivate an asset item, so it will not be attached to a Document * * @param string $type The asset type, script or style * @param string $name The asset name * * @return self * * @throws UnknownAssetException When Asset cannot be found * @throws InvalidActionException When the Manager already attached to a Document * * @since 4.0.0 */ public function disableAsset(string $type, string $name): WebAssetManagerInterface { if ($this->locked) { throw new InvalidActionException('WebAssetManager is locked, you came late'); } // Check whether asset exists $this->registry->get($type, $name); unset($this->activeAssets[$type][$name]); // To re-check dependencies $this->dependenciesIsActual = false; // For Preset case if ($type === 'preset') { $this->disablePresetItems($name); } return $this; } /** * Enable list of assets provided by Preset item. * * "Preset" a special kind of asset that hold a list of assets that has to be enabled, * same as direct call of useAsset() to each of item in list. * Can hold mixed types of assets (script, style, another preset, etc), the type provided after # symbol, after * the asset name, example: foo#style, bar#script. * * The method call useAsset() internally for each of its dependency, this is important for keeping FIFO order * of enabled items. * The Preset not a strict asset, and each of its dependency can be safely disabled by use of disableAsset() later. * * @param string $name The asset name * * @return self * * @throws UnsatisfiedDependencyException When Asset dependency cannot be found * * @since 4.0.0 */ protected function usePresetItems($name): WebAssetManagerInterface { // Get the asset object $asset = $this->registry->get('preset', $name); // Call useAsset() to each of its dependency foreach ($asset->getDependencies() as $dependency) { $depType = ''; $depName = $dependency; $pos = strrpos($dependency, '#'); // Check for cross-dependency "dependency-name#type" case if ($pos) { $depType = substr($dependency, $pos + 1); $depName = substr($dependency, 0, $pos); } $depType = $depType ? $depType : 'preset'; // Make sure dependency exists if (!$this->registry->exists($depType, $depName)) { throw new UnsatisfiedDependencyException( sprintf('Unsatisfied dependency "%s" for an asset "%s" of type "%s"', $dependency, $name, 'preset') ); } $this->useAsset($depType, $depName); } return $this; } /** * Deactivate list of assets provided by Preset item. * * @param string $name The asset name * * @return self * * @throws UnsatisfiedDependencyException When Asset dependency cannot be found * * @since 4.0.0 */ protected function disablePresetItems($name): WebAssetManagerInterface { // Get the asset object $asset = $this->registry->get('preset', $name); // Call disableAsset() to each of its dependency foreach ($asset->getDependencies() as $dependency) { $depType = ''; $depName = $dependency; $pos = strrpos($dependency, '#'); // Check for cross-dependency "dependency-name#type" case if ($pos) { $depType = substr($dependency, $pos + 1); $depName = substr($dependency, 0, $pos); } $depType = $depType ? $depType : 'preset'; // Make sure dependency exists if (!$this->registry->exists($depType, $depName)) { throw new UnsatisfiedDependencyException( sprintf('Unsatisfied dependency "%s" for an asset "%s" of type "%s"', $dependency, $name, 'preset') ); } $this->disableAsset($depType, $depName); } return $this; } /** * Get a state for the Asset * * @param string $type The asset type, script or style * @param string $name The asset name * * @return integer * * @throws UnknownAssetException When Asset cannot be found * * @since 4.0.0 */ public function getAssetState(string $type, string $name): int { // Check whether asset exists first $this->registry->get($type, $name); // Make sure that all dependencies are active if (!$this->dependenciesIsActual) { $this->enableDependencies(); } if (!empty($this->activeAssets[$type][$name])) { return $this->activeAssets[$type][$name]; } return static::ASSET_STATE_INACTIVE; } /** * Check whether the asset are enabled * * @param string $type The asset type, script or style * @param string $name The asset name * * @return boolean * * @throws UnknownAssetException When Asset cannot be found * * @since 4.0.0 */ public function isAssetActive(string $type, string $name): bool { return $this->getAssetState($type, $name) !== static::ASSET_STATE_INACTIVE; } /** * Helper method to check whether the asset exists in the registry. * * @param string $type Asset type, script or style * @param string $name Asset name * * @return boolean * * @since 4.0.0 */ public function assetExists(string $type, string $name): bool { return $this->registry->exists($type, $name); } /** * Register a new asset. * Allow to register WebAssetItem instance in the registry, by call registerAsset($type, $assetInstance) * Or create an asset on fly (from name and Uri) and register in the registry, by call registerAsset($type, $assetName, $uri, $options ....) * * @param string $type The asset type, script or style * @param WebAssetItem|string $asset The asset name or instance to register * @param string $uri The URI for the asset * @param array $options Additional options for the asset * @param array $attributes Attributes for the asset * @param array $dependencies Asset dependencies * * @return self * * @since 4.0.0 * * @throws \InvalidArgumentException */ public function registerAsset(string $type, $asset, string $uri = '', array $options = [], array $attributes = [], array $dependencies = []) { if ($asset instanceof WebAssetItemInterface) { $this->registry->add($type, $asset); } elseif (is_string($asset)) { $options['type'] = $type; $assetInstance = $this->registry->createAsset($asset, $uri, $options, $attributes, $dependencies); $this->registry->add($type, $assetInstance); } else { throw new \InvalidArgumentException( sprintf( '%s(): Argument #2 ($asset) must be a string or an instance of %s, %s given.', __METHOD__, WebAssetItemInterface::class, \is_object($asset) ? \get_class($asset) : \gettype($asset) ) ); } return $this; } /** * Helper method to get the asset from the registry. * * @param string $type Asset type, script or style * @param string $name Asset name * * @return WebAssetItemInterface * * @throws UnknownAssetException When Asset cannot be found * * @since 4.0.0 */ public function getAsset(string $type, string $name): WebAssetItemInterface { return $this->registry->get($type, $name); } /** * Get all active assets, optionally sort them to follow the dependency Graph * * @param string $type The asset type, script or style * @param bool $sort Whether need to sort the assets to follow the dependency Graph * * @return WebAssetItem[] * * @throws UnknownAssetException When Asset cannot be found * @throws UnsatisfiedDependencyException When Dependency cannot be found * * @since 4.0.0 */ public function getAssets(string $type, bool $sort = false): array { // Make sure that all dependencies are active if (!$this->dependenciesIsActual) { $this->enableDependencies(); } if (empty($this->activeAssets[$type])) { return []; } // Apply Tree sorting for regular asset items, but return FIFO order for "preset" if ($sort && $type !== 'preset') { $assets = $this->calculateOrderOfActiveAssets($type); } else { $assets = []; foreach (array_keys($this->activeAssets[$type]) as $name) { $assets[$name] = $this->registry->get($type, $name); } } return $assets; } /** * Helper method to calculate inline to non inline relation (before/after positions). * Return associated array, which contain dependency (handle) name as key, and list of inline items for each position. * Example: ['handle.name' => ['before' => ['inline1', 'inline2'], 'after' => ['inline3', 'inline4']]] * * Note: If inline asset have a multiple dependencies, then will be used last one from the list for positioning * * @param WebAssetItem[] $assets The assets list * * @return array * * @since 4.0.0 */ public function getInlineRelation(array $assets): array { $inlineRelation = []; // Find an inline assets and their relations to non inline foreach ($assets as $k => $asset) { if (!$asset->getOption('inline')) { continue; } // Add to list of inline assets $inlineAssets[$asset->getName()] = $asset; // Check whether position are requested with dependencies $position = $asset->getOption('position'); $position = $position === 'before' || $position === 'after' ? $position : null; $deps = $asset->getDependencies(); if ($position && $deps) { // If inline asset have a multiple dependencies, then use last one from the list for positioning $handle = end($deps); $inlineRelation[$handle][$position][$asset->getName()] = $asset; } } return $inlineRelation; } /** * Helper method to filter an inline assets * * @param WebAssetItem[] $assets Reference to a full list of active assets * * @return WebAssetItem[] Array of inline assets * * @since 4.0.0 */ public function filterOutInlineAssets(array &$assets): array { $inlineAssets = []; foreach ($assets as $k => $asset) { if (!$asset->getOption('inline')) { continue; } // Remove inline assets from assets list, and add to list of inline unset($assets[$k]); $inlineAssets[$asset->getName()] = $asset; } return $inlineAssets; } /** * Add a new inline content asset. * Allow to register WebAssetItem instance in the registry, by call addInline($type, $assetInstance) * Or create an asset on fly (from name and Uri) and register in the registry, by call addInline($type, $content, $options ....) * * @param string $type The asset type, script or style * @param WebAssetItem|string $content The content to of inline asset * @param array $options Additional options for the asset * @param array $attributes Attributes for the asset * @param array $dependencies Asset dependencies * * @return self * * @since 4.0.0 * * @throws \InvalidArgumentException */ public function addInline(string $type, $content, array $options = [], array $attributes = [], array $dependencies = []): self { if ($content instanceof WebAssetItemInterface) { $assetInstance = $content; } elseif (is_string($content)) { $name = $options['name'] ?? ('inline.' . md5($content)); $assetInstance = $this->registry->createAsset($name, '', $options, $attributes, $dependencies); $assetInstance->setOption('content', $content); } else { throw new \InvalidArgumentException( sprintf( '%s(): Argument #2 ($content) must be a string or an instance of %s, %s given.', __METHOD__, WebAssetItemInterface::class, \is_object($content) ? \get_class($content) : \gettype($content) ) ); } // Get the name $asset = $assetInstance->getName(); // Set required options $assetInstance->setOption('type', $type); $assetInstance->setOption('inline', true); // Add to registry $this->registry->add($type, $assetInstance); // And make active $this->useAsset($type, $asset); return $this; } /** * Lock the manager to prevent further modifications * * @return self * * @since 4.0.0 */ public function lock(): self { $this->locked = true; return $this; } /** * Get the manager state. A collection of registry files and active asset names (per type). * * @return array * * @since 4.0.0 */ public function getManagerState(): array { return [ 'registryFiles' => $this->getRegistry()->getRegistryFiles(), 'activeAssets' => $this->activeAssets, ]; } /** * Update Dependencies state for all active Assets or only for given * * @param string $type The asset type, script or style * @param WebAssetItem $asset The asset instance to which need to enable dependencies * * @return self * * @since 4.0.0 */ protected function enableDependencies(string $type = null, WebAssetItem $asset = null): self { if ($type === 'preset') { // Preset items already was enabled by usePresetItems() return $this; } if ($asset) { // Get all dependencies of given asset recursively $allDependencies = $this->getDependenciesForAsset($type, $asset, true); foreach ($allDependencies as $depType => $depItems) { foreach ($depItems as $depItem) { // Set dependency state only when it is inactive, to keep a manually activated Asset in their original state if (empty($this->activeAssets[$depType][$depItem->getName()])) { // Add the dependency at the top of the list of active assets $this->activeAssets[$depType] = [$depItem->getName() => static::ASSET_STATE_DEPENDENCY] + $this->activeAssets[$depType]; } } } } else { // Re-Check for dependencies for all active assets // Firstly, filter out only active assets foreach ($this->activeAssets as $type => $activeAsset) { $this->activeAssets[$type] = array_filter( $activeAsset, function ($state) { return $state === WebAssetManager::ASSET_STATE_ACTIVE; } ); } // Secondary, check for dependencies of each active asset // This need to be separated from previous step because we may have "cross type" dependency foreach ($this->activeAssets as $type => $activeAsset) { foreach (array_keys($activeAsset) as $name) { $asset = $this->registry->get($type, $name); $this->enableDependencies($type, $asset); } } $this->dependenciesIsActual = true; } return $this; } /** * Calculate weight of active Assets, by its Dependencies * * @param string $type The asset type, script or style * * @return WebAssetItem[] * * @since 4.0.0 */ protected function calculateOrderOfActiveAssets($type): array { // See https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm $graphOrder = []; $activeAssets = $this->getAssets($type, false); // Get Graph of Outgoing and Incoming connections $connectionsGraph = $this->getConnectionsGraph($activeAssets); $graphOutgoing = $connectionsGraph['outgoing']; $graphIncoming = $connectionsGraph['incoming']; // Make a copy to be used during weight processing $graphIncomingCopy = $graphIncoming; // Find items without incoming connections $emptyIncoming = array_keys( array_filter( $graphIncoming, function ($el) { return !$el; } ) ); // Reverse, to start from a last enabled and move up to a first enabled, this helps to maintain an original sorting $emptyIncoming = array_reverse($emptyIncoming); // Loop through, and sort the graph while ($emptyIncoming) { // Add the node without incoming connection to the result $item = array_shift($emptyIncoming); $graphOrder[] = $item; // Check of each neighbor of the node foreach (array_reverse($graphOutgoing[$item]) as $neighbor) { // Remove incoming connection of already visited node unset($graphIncoming[$neighbor][$item]); // If there no more incoming connections add the node to queue if (empty($graphIncoming[$neighbor])) { $emptyIncoming[] = $neighbor; } } } // Sync Graph order with FIFO order $fifoWeights = []; $graphWeights = []; $requestedWeights = []; foreach (array_keys($this->activeAssets[$type]) as $index => $name) { $fifoWeights[$name] = $index * 10 + 10; } foreach (array_reverse($graphOrder) as $index => $name) { $graphWeights[$name] = $index * 10 + 10; $requestedWeights[$name] = $activeAssets[$name]->getOption('weight') ?: $fifoWeights[$name]; } // Try to set a requested weight, or make it close as possible to requested, but keep the Graph order while ($requestedWeights) { $item = key($requestedWeights); $weight = array_shift($requestedWeights); // Skip empty items if ($weight === null) { continue; } // Check the predecessors (Outgoing vertexes), the weight cannot be lighter than the predecessor have $topBorder = $weight - 1; if (!empty($graphOutgoing[$item])) { $prevWeights = []; foreach ($graphOutgoing[$item] as $pItem) { $prevWeights[] = $graphWeights[$pItem]; } $topBorder = max($prevWeights); } // Calculate a new weight $newWeight = $weight > $topBorder ? $weight : $topBorder + 1; // If a new weight heavier than existing, then we need to update all incoming connections (children) if ($newWeight > $graphWeights[$item] && !empty($graphIncomingCopy[$item])) { // Sort Graph of incoming by actual position foreach ($graphIncomingCopy[$item] as $incomingItem) { // Set a weight heavier than current, then this node to be processed in next iteration if (empty($requestedWeights[$incomingItem])) { $requestedWeights[$incomingItem] = $graphWeights[$incomingItem] + $newWeight; } } } // Set a new weight $graphWeights[$item] = $newWeight; } asort($graphWeights); // Get Assets in calculated order $resultAssets = []; foreach (array_keys($graphWeights) as $name) { $resultAssets[$name] = $activeAssets[$name]; } return $resultAssets; } /** * Build Graph of Outgoing and Incoming connections for given assets. * * @param WebAssetItem[] $assets Asset instances * * @return array * * @since 4.0.0 */ protected function getConnectionsGraph(array $assets): array { $graphOutgoing = []; $graphIncoming = []; foreach ($assets as $asset) { $name = $asset->getName(); // Initialise an array for outgoing nodes of the asset $graphOutgoing[$name] = []; // Initialise an array for incoming nodes of the asset if (!\array_key_exists($name, $graphIncoming)) { $graphIncoming[$name] = []; } // Collect an outgoing/incoming nodes foreach ($asset->getDependencies() as $depName) { $graphOutgoing[$name][$depName] = $depName; $graphIncoming[$depName][$name] = $name; } } return [ 'outgoing' => $graphOutgoing, 'incoming' => $graphIncoming, ]; } /** * Return dependencies for Asset as array of WebAssetItem objects * * @param string $type The asset type, script or style * @param WebAssetItem $asset Asset instance * @param boolean $recursively Whether to search for dependency recursively * @param string $recursionType The type of initial item to prevent loop * @param WebAssetItem $recursionRoot Initial item to prevent loop * * @return array * * @throws UnsatisfiedDependencyException When Dependency cannot be found * * @since 4.0.0 */ protected function getDependenciesForAsset( string $type, WebAssetItem $asset, $recursively = false, string $recursionType = null, WebAssetItem $recursionRoot = null ): array { $assets = []; $recursionRoot = $recursionRoot ?? $asset; $recursionType = $recursionType ?? $type; foreach ($asset->getDependencies() as $depName) { $depType = $type; // Skip already loaded in recursion if ($recursionRoot->getName() === $depName && $recursionType === $depType) { continue; } if (!$this->registry->exists($depType, $depName)) { throw new UnsatisfiedDependencyException( sprintf('Unsatisfied dependency "%s" for an asset "%s" of type "%s"', $depName, $asset->getName(), $depType) ); } $dep = $this->registry->get($depType, $depName); $assets[$depType][$depName] = $dep; if (!$recursively) { continue; } $parentDeps = $this->getDependenciesForAsset($depType, $dep, true, $recursionType, $recursionRoot); $assets = array_replace_recursive($assets, $parentDeps); } return $assets; } }