FileModule.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ResourceLoader;
 
use CSSJanus;
use Exception;
use FileContentsHasher;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Languages\LanguageFallback;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Output\OutputPage;
use MediaWiki\Registration\ExtensionRegistry;
use RuntimeException;
use Wikimedia\Minify\CSSMin;
use Wikimedia\RequestTimeout\TimeoutException;
 
class FileModule extends Module {
    protected $localBasePath = '';
 
    protected $remoteBasePath = '';
 
    protected $scripts = [];
 
    protected $languageScripts = [];
 
    protected $skinScripts = [];
 
    protected $debugScripts = [];
 
    protected $styles = [];
 
    protected $skinStyles = [];
 
    protected $packageFiles = null;
 
    private $expandedPackageFiles = [];
 
    private $fullyExpandedPackageFiles = [];
 
    protected $dependencies = [];
 
    protected $skipFunction = null;
 
    protected $messages = [];
 
    protected $templates = [];
 
    protected $group = null;
 
    protected $debugRaw = true;
 
    protected $noflip = false;
 
    protected $skipStructureTest = false;
 
    protected $hasGeneratedStyles = false;
 
    protected $localFileRefs = [];
 
    protected $missingLocalFileRefs = [];
 
    protected $vueComponentParser = null;
 
    public function __construct(
        array $options = [],
        ?string $localBasePath = null,
        ?string $remoteBasePath = null
    ) {
        // Flag to decide whether to automagically add the mediawiki.template module
        $hasTemplates = false;
        // localBasePath and remoteBasePath both have unbelievably long fallback chains
        // and need to be handled separately.
        [ $this->localBasePath, $this->remoteBasePath ] =
            self::extractBasePaths( $options, $localBasePath, $remoteBasePath );
 
        // Extract, validate and normalise remaining options
        foreach ( $options as $member => $option ) {
            switch ( $member ) {
                // Lists of file paths
                case 'scripts':
                case 'debugScripts':
                case 'styles':
                case 'packageFiles':
                    $this->{$member} = is_array( $option ) ? $option : [ $option ];
                    break;
                case 'templates':
                    $hasTemplates = true;
                    $this->{$member} = is_array( $option ) ? $option : [ $option ];
                    break;
                // Collated lists of file paths
                case 'languageScripts':
                case 'skinScripts':
                case 'skinStyles':
                    if ( !is_array( $option ) ) {
                        throw new InvalidArgumentException(
                            "Invalid collated file path list error. " .
                            "'$option' given, array expected."
                        );
                    }
                    foreach ( $option as $key => $value ) {
                        if ( !is_string( $key ) ) {
                            throw new InvalidArgumentException(
                                "Invalid collated file path list key error. " .
                                "'$key' given, string expected."
                            );
                        }
                        $this->{$member}[$key] = is_array( $value ) ? $value : [ $value ];
                    }
                    break;
                case 'deprecated':
                    $this->deprecated = $option;
                    break;
                // Lists of strings
                case 'dependencies':
                case 'messages':
                    // Normalise
                    $option = array_values( array_unique( (array)$option ) );
                    sort( $option );
 
                    $this->{$member} = $option;
                    break;
                // Single strings
                case 'group':
                case 'skipFunction':
                    $this->{$member} = (string)$option;
                    break;
                // Single booleans
                case 'debugRaw':
                case 'noflip':
                case 'skipStructureTest':
                    $this->{$member} = (bool)$option;
                    break;
            }
        }
        if ( isset( $options['scripts'] ) && isset( $options['packageFiles'] ) ) {
            throw new InvalidArgumentException( "A module may not set both 'scripts' and 'packageFiles'" );
        }
        if ( isset( $options['packageFiles'] ) && isset( $options['skinScripts'] ) ) {
            throw new InvalidArgumentException( "Options 'skinScripts' and 'packageFiles' cannot be used together." );
        }
        if ( $hasTemplates ) {
            $this->dependencies[] = 'mediawiki.template';
            // Ensure relevant template compiler module gets loaded
            foreach ( $this->templates as $alias => $templatePath ) {
                if ( is_int( $alias ) ) {
                    $alias = $this->getPath( $templatePath );
                }
                $suffix = explode( '.', $alias );
                $suffix = end( $suffix );
                $compilerModule = 'mediawiki.template.' . $suffix;
                if ( $suffix !== 'html' && !in_array( $compilerModule, $this->dependencies ) ) {
                    $this->dependencies[] = $compilerModule;
                }
            }
        }
    }
 
    public static function extractBasePaths(
        array $options = [],
        $localBasePath = null,
        $remoteBasePath = null
    ) {
        // The different ways these checks are done, and their ordering, look very silly,
        // but were preserved for backwards-compatibility just in case. Tread lightly.
 
        $remoteBasePath ??= MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::ResourceBasePath );
 
        if ( isset( $options['remoteExtPath'] ) ) {
            $extensionAssetsPath = MediaWikiServices::getInstance()->getMainConfig()
                ->get( MainConfigNames::ExtensionAssetsPath );
            $remoteBasePath = $extensionAssetsPath . '/' . $options['remoteExtPath'];
        }
 
        if ( isset( $options['remoteSkinPath'] ) ) {
            $stylePath = MediaWikiServices::getInstance()->getMainConfig()
                ->get( MainConfigNames::StylePath );
            $remoteBasePath = $stylePath . '/' . $options['remoteSkinPath'];
        }
 
        if ( array_key_exists( 'localBasePath', $options ) ) {
            $localBasePath = (string)$options['localBasePath'];
        }
 
        if ( array_key_exists( 'remoteBasePath', $options ) ) {
            $remoteBasePath = (string)$options['remoteBasePath'];
        }
 
        if ( $remoteBasePath === '' ) {
            // If MediaWiki is installed at the document root (not recommended),
            // then wgScriptPath is set to the empty string by the installer to
            // ensure safe concatenating of file paths (avoid "/" + "/foo" being "//foo").
            // However, this also means the path itself can be an invalid URI path,
            // as those must start with a slash. Within ResourceLoader, we will not
            // do such primitive/unsafe slash concatenation and use URI resolution
            // instead, so beyond this point, to avoid fatal errors in CSSMin::resolveUrl(),
            // do a best-effort support for docroot installs by casting this to a slash.
            $remoteBasePath = '/';
        }
 
        return [ $localBasePath ?? MW_INSTALL_PATH, $remoteBasePath ];
    }
 
    public function getScript( Context $context ) {
        $packageFiles = $this->getPackageFiles( $context );
        if ( $packageFiles !== null ) {
            foreach ( $packageFiles['files'] as &$file ) {
                if ( $file['type'] === 'script+style' ) {
                    $file['content'] = $file['content']['script'];
                    $file['type'] = 'script';
                }
            }
            return $packageFiles;
        }
 
        $files = $this->getScriptFiles( $context );
        foreach ( $files as &$file ) {
            $this->readFileInfo( $context, $file );
        }
        return [ 'plainScripts' => $files ];
    }
 
    public function getScriptURLsForDebug( Context $context ) {
        $rl = $context->getResourceLoader();
        $config = $this->getConfig();
        $server = $config->get( MainConfigNames::Server );
 
        $urls = [];
        foreach ( $this->getScriptFiles( $context ) as $file ) {
            if ( isset( $file['filePath'] ) ) {
                $url = OutputPage::transformResourcePath( $config, $this->getRemotePath( $file['filePath'] ) );
                // Expand debug URL in case we are another wiki's module source (T255367)
                $url = $rl->expandUrl( $server, $url );
                $urls[] = $url;
            }
        }
        return $urls;
    }
 
    public function supportsURLLoading() {
        // phpcs:ignore Generic.WhiteSpace.LanguageConstructSpacing.IncorrectSingle
        return
            // Denied by options?
            $this->debugRaw
            // If package files are involved, don't support URL loading, because that breaks
            // scoped require() functions
            && !$this->packageFiles
            // Can't link to scripts generated by callbacks
            && !$this->hasGeneratedScripts();
    }
 
    public function shouldSkipStructureTest() {
        return $this->skipStructureTest || parent::shouldSkipStructureTest();
    }
 
    private function hasGeneratedScripts() {
        foreach (
            [ $this->scripts, $this->languageScripts, $this->skinScripts, $this->debugScripts ]
            as $scripts
        ) {
            foreach ( $scripts as $script ) {
                if ( is_array( $script ) ) {
                    if ( isset( $script['callback'] ) || isset( $script['versionCallback'] ) ) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
 
    public function getStyles( Context $context ) {
        $styles = $this->readStyleFiles(
            $this->getStyleFiles( $context ),
            $context
        );
 
        $packageFiles = $this->getPackageFiles( $context );
        if ( $packageFiles !== null ) {
            foreach ( $packageFiles['files'] as $fileName => $file ) {
                if ( $file['type'] === 'script+style' ) {
                    $style = $this->processStyle(
                        $file['content']['style'],
                        $file['content']['styleLang'],
                        $fileName,
                        $context
                    );
                    $styles['all'] = ( $styles['all'] ?? '' ) . "\n" . $style;
                }
            }
        }
 
        // Track indirect file dependencies so that StartUpModule can check for
        // on-disk file changes to any of this files without having to recompute the file list
        $this->saveFileDependencies( $context, $this->localFileRefs );
 
        return $styles;
    }
 
    public function getStyleURLsForDebug( Context $context ) {
        if ( $this->hasGeneratedStyles ) {
            // Do the default behaviour of returning a url back to load.php
            // but with only=styles.
            return parent::getStyleURLsForDebug( $context );
        }
        // Our module consists entirely of real css files,
        // in debug mode we can load those directly.
        $urls = [];
        foreach ( $this->getStyleFiles( $context ) as $mediaType => $list ) {
            $urls[$mediaType] = [];
            foreach ( $list as $file ) {
                $urls[$mediaType][] = OutputPage::transformResourcePath(
                    $this->getConfig(),
                    $this->getRemotePath( $file )
                );
            }
        }
        return $urls;
    }
 
    public function getMessages() {
        return $this->messages;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function getDependencies( ?Context $context = null ) {
        return $this->dependencies;
    }
 
    private function getFileContents( $localPath, $type ) {
        if ( !is_file( $localPath ) ) {
            throw new RuntimeException( "$type file not found or not a file: \"$localPath\"" );
        }
        return $this->stripBom( file_get_contents( $localPath ) );
    }
 
    public function getSkipFunction() {
        if ( !$this->skipFunction ) {
            return null;
        }
        $localPath = $this->getLocalPath( $this->skipFunction );
        return $this->getFileContents( $localPath, 'skip function' );
    }
 
    public function requiresES6() {
        return true;
    }
 
    public function enableModuleContentVersion() {
        return false;
    }
 
    private function getFileHashes( Context $context ) {
        $files = [];
 
        foreach ( $this->getStyleFiles( $context ) as $filePaths ) {
            foreach ( $filePaths as $filePath ) {
                $files[] = $this->getLocalPath( $filePath );
            }
        }
 
        // Extract file paths for package files
        // Optimisation: Use foreach() and isset() instead of array_map/array_filter.
        // This is a hot code path, called by StartupModule for thousands of modules.
        $expandedPackageFiles = $this->expandPackageFiles( $context );
        if ( $expandedPackageFiles ) {
            foreach ( $expandedPackageFiles['files'] as $fileInfo ) {
                if ( isset( $fileInfo['filePath'] ) ) {
                    $filePath = $fileInfo['filePath'];
                    $files[] = $filePath->getLocalPath();
                }
            }
        }
 
        // Add other configured paths
        $scriptFileInfos = $this->getScriptFiles( $context );
        foreach ( $scriptFileInfos as $fileInfo ) {
            $filePath = $fileInfo['filePath'] ?? $fileInfo['versionFilePath'] ?? null;
            if ( $filePath instanceof FilePath ) {
                $files[] = $filePath->getLocalPath();
            }
        }
 
        foreach ( $this->templates as $filePath ) {
            $files[] = $this->getLocalPath( $filePath );
        }
 
        if ( $this->skipFunction ) {
            $files[] = $this->getLocalPath( $this->skipFunction );
        }
 
        // Add any lazily discovered file dependencies from previous module builds.
        // These are already absolute paths.
        foreach ( $this->getFileDependencies( $context ) as $file ) {
            $files[] = $file;
        }
 
        // Filter out any duplicates. Typically introduced by getFileDependencies() which
        // may lazily re-discover a primary file.
        $files = array_unique( $files );
 
        // Don't return array keys or any other form of file path here, only the hashes.
        // Including file paths would needlessly cause global cache invalidation when files
        // move on disk or if e.g. the MediaWiki directory name changes.
        // Anything where order is significant is already detected by the definition summary.
        return FileContentsHasher::getFileContentsHash( $files );
    }
 
    public function getDefinitionSummary( Context $context ) {
        $summary = parent::getDefinitionSummary( $context );
 
        $options = [];
        foreach ( [
            // The following properties are omitted because they don't affect the module response:
            // - localBasePath (Per T104950; Changes when absolute directory name changes. If
            //    this affects 'scripts' and other file paths, getFileHashes accounts for that.)
            // - remoteBasePath (Per T104950)
            // - dependencies (provided via startup module)
            // - group (provided via startup module)
            'styles',
            'skinStyles',
            'messages',
            'templates',
            'skipFunction',
            'debugRaw',
        ] as $member ) {
            $options[$member] = $this->{$member};
        }
 
        $packageFiles = $this->expandPackageFiles( $context );
        $packageSummaries = [];
        if ( $packageFiles ) {
            // Extract the minimum needed:
            // - The 'main' pointer (included as-is).
            // - The 'files' array, simplified to only which files exist (the keys of
            //   this array), and something that represents their non-file content.
            //   For packaged files that reflect files directly from disk, the
            //   'getFileHashes' method tracks their content already.
            //   It is important that the keys of the $packageFiles['files'] array
            //   are preserved, as they do affect the module output.
            foreach ( $packageFiles['files'] as $fileName => $fileInfo ) {
                $packageSummaries[$fileName] =
                    $fileInfo['definitionSummary'] ?? $fileInfo['content'] ?? null;
            }
        }
 
        $scriptFiles = $this->getScriptFiles( $context );
        $scriptSummaries = [];
        foreach ( $scriptFiles as $fileName => $fileInfo ) {
            $scriptSummaries[$fileName] =
                $fileInfo['definitionSummary'] ?? $fileInfo['content'] ?? null;
        }
 
        $summary[] = [
            'options' => $options,
            'packageFiles' => $packageSummaries,
            'scripts' => $scriptSummaries,
            'fileHashes' => $this->getFileHashes( $context ),
            'messageBlob' => $this->getMessageBlob( $context ),
        ];
 
        $lessVars = $this->getLessVars( $context );
        if ( $lessVars ) {
            $summary[] = [ 'lessVars' => $lessVars ];
        }
 
        return $summary;
    }
 
    protected function getVueComponentParser() {
        if ( $this->vueComponentParser === null ) {
            $this->vueComponentParser = new VueComponentParser;
        }
        return $this->vueComponentParser;
    }
 
    protected function getPath( $path ) {
        if ( $path instanceof FilePath ) {
            return $path->getPath();
        }
 
        return $path;
    }
 
    protected function getLocalPath( $path ) {
        if ( $path instanceof FilePath ) {
            if ( $path->getLocalBasePath() !== null ) {
                return $path->getLocalPath();
            }
            $path = $path->getPath();
        }
 
        return "{$this->localBasePath}/$path";
    }
 
    protected function getRemotePath( $path ) {
        if ( $path instanceof FilePath ) {
            if ( $path->getRemoteBasePath() !== null ) {
                return $path->getRemotePath();
            }
            $path = $path->getPath();
        }
 
        if ( $this->remoteBasePath === '/' ) {
            return "/$path";
        } else {
            return "{$this->remoteBasePath}/$path";
        }
    }
 
    public function getStyleSheetLang( $path ) {
        return preg_match( '/\.less$/i', $path ) ? 'less' : 'css';
    }
 
    public static function getPackageFileType( $path ) {
        if ( preg_match( '/\.json$/i', $path ) ) {
            return 'data';
        }
        if ( preg_match( '/\.vue$/i', $path ) ) {
            return 'script-vue';
        }
        return 'script';
    }
 
    private static function collateStyleFilesByMedia( array $list ) {
        $collatedFiles = [];
        foreach ( $list as $key => $value ) {
            if ( is_int( $key ) ) {
                // File name as the value
                $collatedFiles['all'][] = $value;
            } elseif ( is_array( $value ) ) {
                // File name as the key, options array as the value
                $optionValue = $value['media'] ?? 'all';
                $collatedFiles[$optionValue][] = $key;
            }
        }
        return $collatedFiles;
    }
 
    protected static function tryForKey( array $list, $key, $fallback = null ) {
        if ( isset( $list[$key] ) && is_array( $list[$key] ) ) {
            return $list[$key];
        } elseif ( is_string( $fallback )
            && isset( $list[$fallback] )
            && is_array( $list[$fallback] )
        ) {
            return $list[$fallback];
        }
        return [];
    }
 
    private function getScriptFiles( Context $context ): array {
        // List in execution order: scripts, languageScripts, skinScripts, debugScripts.
        // Documented at MediaWiki\MainConfigSchema::ResourceModules.
        $filesByCategory = [
            'scripts' => $this->scripts,
            'languageScripts' => $this->getLanguageScripts( $context->getLanguage() ),
            'skinScripts' => self::tryForKey( $this->skinScripts, $context->getSkin(), 'default' ),
        ];
        if ( $context->getDebug() ) {
            $filesByCategory['debugScripts'] = $this->debugScripts;
        }
 
        $expandedFiles = [];
        foreach ( $filesByCategory as $category => $files ) {
            foreach ( $files as $key => $fileInfo ) {
                $expandedFileInfo = $this->expandFileInfo( $context, $fileInfo, "$category\[$key]" );
                $expandedFiles[$expandedFileInfo['name']] = $expandedFileInfo;
            }
        }
 
        return $expandedFiles;
    }
 
    private function getLanguageScripts( string $lang ): array {
        $scripts = self::tryForKey( $this->languageScripts, $lang );
        if ( $scripts ) {
            return $scripts;
        }
 
        // Optimization: Avoid initialising and calling into language services
        // for the majority of modules that don't use this option.
        if ( $this->languageScripts ) {
            $fallbacks = MediaWikiServices::getInstance()
                ->getLanguageFallback()
                ->getAll( $lang, LanguageFallback::MESSAGES );
            foreach ( $fallbacks as $lang ) {
                $scripts = self::tryForKey( $this->languageScripts, $lang );
                if ( $scripts ) {
                    return $scripts;
                }
            }
        }
 
        return [];
    }
 
    public function setSkinStylesOverride( array $moduleSkinStyles ): void {
        $moduleName = $this->getName();
        foreach ( $moduleSkinStyles as $skinName => $overrides ) {
            // If a module provides overrides for a skin, and that skin also provides overrides
            // for the same module, then the module has precedence.
            if ( isset( $this->skinStyles[$skinName] ) ) {
                continue;
            }
 
            // If $moduleName in ResourceModuleSkinStyles is preceded with a '+', the defined style
            // files will be added to 'default' skinStyles, otherwise 'default' will be ignored.
            if ( isset( $overrides[$moduleName] ) ) {
                $paths = (array)$overrides[$moduleName];
                $styleFiles = [];
            } elseif ( isset( $overrides['+' . $moduleName] ) ) {
                $paths = (array)$overrides['+' . $moduleName];
                $styleFiles = isset( $this->skinStyles['default'] ) ?
                    (array)$this->skinStyles['default'] :
                    [];
            } else {
                continue;
            }
 
            // Add new file paths, remapping them to refer to our directories and not use settings
            // from the module we're modifying, which come from the base definition.
            [ $localBasePath, $remoteBasePath ] = self::extractBasePaths( $overrides );
 
            foreach ( $paths as $path ) {
                $styleFiles[] = new FilePath( $path, $localBasePath, $remoteBasePath );
            }
 
            $this->skinStyles[$skinName] = $styleFiles;
        }
    }
 
    public function getStyleFiles( Context $context ) {
        return array_merge_recursive(
            self::collateStyleFilesByMedia( $this->styles ),
            self::collateStyleFilesByMedia(
                self::tryForKey( $this->skinStyles, $context->getSkin(), 'default' )
            )
        );
    }
 
    protected function getSkinStyleFiles( $skinName ) {
        return self::collateStyleFilesByMedia(
            self::tryForKey( $this->skinStyles, $skinName )
        );
    }
 
    protected function getAllSkinStyleFiles() {
        $skinFactory = MediaWikiServices::getInstance()->getSkinFactory();
        $styleFiles = [];
 
        $internalSkinNames = array_keys( $skinFactory->getInstalledSkins() );
        $internalSkinNames[] = 'default';
 
        foreach ( $internalSkinNames as $internalSkinName ) {
            $styleFiles = array_merge_recursive(
                $styleFiles,
                $this->getSkinStyleFiles( $internalSkinName )
            );
        }
 
        return $styleFiles;
    }
 
    public function getAllStyleFiles() {
        $collatedStyleFiles = array_merge_recursive(
            self::collateStyleFilesByMedia( $this->styles ),
            $this->getAllSkinStyleFiles()
        );
 
        $result = [];
 
        foreach ( $collatedStyleFiles as $styleFiles ) {
            foreach ( $styleFiles as $styleFile ) {
                $result[] = $this->getLocalPath( $styleFile );
            }
        }
 
        return $result;
    }
 
    public function readStyleFiles( array $styles, Context $context ) {
        if ( !$styles ) {
            return [];
        }
        foreach ( $styles as $media => $files ) {
            $uniqueFiles = array_unique( $files, SORT_REGULAR );
            $styleFiles = [];
            foreach ( $uniqueFiles as $file ) {
                $styleFiles[] = $this->readStyleFile( $file, $context );
            }
            $styles[$media] = implode( "\n", $styleFiles );
        }
        return $styles;
    }
 
    protected function readStyleFile( $path, Context $context ) {
        $localPath = $this->getLocalPath( $path );
        $style = $this->getFileContents( $localPath, 'style' );
        $styleLang = $this->getStyleSheetLang( $localPath );
 
        return $this->processStyle( $style, $styleLang, $path, $context );
    }
 
    protected function processStyle( $style, $styleLang, $path, Context $context ) {
        $localPath = $this->getLocalPath( $path );
        $remotePath = $this->getRemotePath( $path );
 
        if ( $styleLang === 'less' ) {
            $style = $this->compileLessString( $style, $localPath, $context );
            $this->hasGeneratedStyles = true;
        }
 
        if ( $this->getFlip( $context ) ) {
            $style = CSSJanus::transform(
                $style,
                /* $swapLtrRtlInURL = */ true,
                /* $swapLeftRightInURL = */ false
            );
            $this->hasGeneratedStyles = true;
        }
 
        $localDir = dirname( $localPath );
        $remoteDir = dirname( $remotePath );
        // Get and register local file references
        $localFileRefs = CSSMin::getLocalFileReferences( $style, $localDir );
        foreach ( $localFileRefs as $file ) {
            if ( is_file( $file ) ) {
                $this->localFileRefs[] = $file;
            } else {
                $this->missingLocalFileRefs[] = $file;
            }
        }
        // Don't cache this call. remap() ensures data URIs embeds are up to date,
        // and urls contain correct content hashes in their query string. (T128668)
        return CSSMin::remap( $style, $localDir, $remoteDir, true );
    }
 
    public function getFlip( Context $context ) {
        return $context->getDirection() === 'rtl' && !$this->noflip;
    }
 
    public function getType() {
        $canBeStylesOnly = !(
            // All options except 'styles', 'skinStyles' and 'debugRaw'
            $this->scripts
            || $this->debugScripts
            || $this->templates
            || $this->languageScripts
            || $this->skinScripts
            || $this->dependencies
            || $this->messages
            || $this->skipFunction
            || $this->packageFiles
        );
        return $canBeStylesOnly ? self::LOAD_STYLES : self::LOAD_GENERAL;
    }
 
    protected function compileLessString( $style, $stylePath, Context $context ) {
        static $cache;
        // @TODO: dependency injection
        if ( !$cache ) {
            $cache = MediaWikiServices::getInstance()->getObjectCacheFactory()
                ->getLocalServerInstance( CACHE_HASH );
        }
 
        $skinName = $context->getSkin();
        $skinImportPaths = ExtensionRegistry::getInstance()->getAttribute( 'SkinLessImportPaths' );
        $importDirs = [];
        if ( isset( $skinImportPaths[ $skinName ] ) ) {
            $importDirs[] = $skinImportPaths[ $skinName ];
        }
 
        $vars = $this->getLessVars( $context );
        // Construct a cache key from a hash of the LESS source, and a hash digest
        // of the LESS variables and import dirs used for compilation.
        ksort( $vars );
        $compilerParams = [
            'vars' => $vars,
            'importDirs' => $importDirs,
            // CodexDevelopmentDir affects import path mapping in ResourceLoader::getLessCompiler(),
            // so take that into account too
            'codexDevDir' => $this->getConfig()->get( MainConfigNames::CodexDevelopmentDir )
        ];
        $key = $cache->makeGlobalKey(
            'resourceloader-less',
            'v1',
            hash( 'md4', $style ),
            hash( 'md4', serialize( $compilerParams ) )
        );
 
        // If we got a cached value, we have to validate it by getting a checksum of all the
        // files that were loaded by the parser and ensuring it matches the cached entry's.
        $data = $cache->get( $key );
        if (
            !$data ||
            $data['hash'] !== FileContentsHasher::getFileContentsHash( $data['files'] )
        ) {
            $compiler = $context->getResourceLoader()->getLessCompiler( $vars, $importDirs );
 
            $css = $compiler->parse( $style, $stylePath )->getCss();
            // T253055: store the implicit dependency paths in a form relative to any install
            // path so that multiple version of the application can share the cache for identical
            // less stylesheets. This also avoids churn during application updates.
            $files = $compiler->getParsedFiles();
            $data = [
                'css'   => $css,
                'files' => Module::getRelativePaths( $files ),
                'hash'  => FileContentsHasher::getFileContentsHash( $files )
            ];
            $cache->set( $key, $data, $cache::TTL_DAY );
        }
 
        foreach ( Module::expandRelativePaths( $data['files'] ) as $path ) {
            $this->localFileRefs[] = $path;
        }
 
        return $data['css'];
    }
 
    public function getTemplates() {
        $templates = [];
 
        foreach ( $this->templates as $alias => $templatePath ) {
            // Alias is optional
            if ( is_int( $alias ) ) {
                $alias = $this->getPath( $templatePath );
            }
            $localPath = $this->getLocalPath( $templatePath );
            $content = $this->getFileContents( $localPath, 'template' );
 
            $templates[$alias] = $this->stripBom( $content );
        }
        return $templates;
    }
 
    private function expandPackageFiles( Context $context ) {
        $hash = $context->getHash();
        if ( isset( $this->expandedPackageFiles[$hash] ) ) {
            return $this->expandedPackageFiles[$hash];
        }
        if ( $this->packageFiles === null ) {
            return null;
        }
        $expandedFiles = [];
        $mainFile = null;
 
        foreach ( $this->packageFiles as $key => $fileInfo ) {
            $expanded = $this->expandFileInfo( $context, $fileInfo, "packageFiles[$key]" );
            $fileName = $expanded['name'];
            if ( !empty( $expanded['main'] ) ) {
                unset( $expanded['main'] );
                $type = $expanded['type'];
                $mainFile = $fileName;
                if ( $type !== 'script' && $type !== 'script-vue' ) {
                    $msg = "Main file in package must be of type 'script', module " .
                        "'{$this->getName()}', main file '{$mainFile}' is '{$type}'.";
                    $this->getLogger()->error( $msg );
                    throw new LogicException( $msg );
                }
            }
            $expandedFiles[$fileName] = $expanded;
        }
 
        if ( $expandedFiles && $mainFile === null ) {
            // The first package file that is a script is the main file
            foreach ( $expandedFiles as $path => $file ) {
                if ( $file['type'] === 'script' || $file['type'] === 'script-vue' ) {
                    $mainFile = $path;
                    break;
                }
            }
        }
 
        $result = [
            'main' => $mainFile,
            'files' => $expandedFiles
        ];
 
        $this->expandedPackageFiles[$hash] = $result;
        return $result;
    }
 
    private function expandFileInfo( Context $context, $fileInfo, $debugKey ) {
        if ( is_string( $fileInfo ) ) {
            // Inline common case
            return [
                'name' => $fileInfo,
                'type' => self::getPackageFileType( $fileInfo ),
                'filePath' => new FilePath( $fileInfo, $this->localBasePath, $this->remoteBasePath )
            ];
        } elseif ( $fileInfo instanceof FilePath ) {
            $fileInfo = [
                'name' => $fileInfo->getPath(),
                'file' => $fileInfo
            ];
        } elseif ( !is_array( $fileInfo ) ) {
            $msg = "Invalid type in $debugKey for module '{$this->getName()}', " .
                "must be array, string or FilePath";
            $this->getLogger()->error( $msg );
            throw new LogicException( $msg );
        }
        if ( !isset( $fileInfo['name'] ) ) {
            $msg = "Missing 'name' key in $debugKey for module '{$this->getName()}'";
            $this->getLogger()->error( $msg );
            throw new LogicException( $msg );
        }
        $fileName = $this->getPath( $fileInfo['name'] );
 
        // Infer type from alias if needed
        $type = $fileInfo['type'] ?? self::getPackageFileType( $fileName );
        $expanded = [
            'name' => $fileName,
            'type' => $type
        ];
        if ( !empty( $fileInfo['main'] ) ) {
            $expanded['main'] = true;
        }
 
        // Perform expansions (except 'file' and 'callback'), creating one of these keys:
        // - 'content': literal value.
        // - 'filePath': content to be read from a file.
        // - 'callback': content computed by a callable.
        if ( isset( $fileInfo['content'] ) ) {
            $expanded['content'] = $fileInfo['content'];
        } elseif ( isset( $fileInfo['file'] ) ) {
            $expanded['filePath'] = $this->makeFilePath( $fileInfo['file'] );
        } elseif ( isset( $fileInfo['callback'] ) ) {
            // If no extra parameter for the callback is given, use null.
            $expanded['callbackParam'] = $fileInfo['callbackParam'] ?? null;
 
            if ( !is_callable( $fileInfo['callback'] ) ) {
                $msg = "Invalid 'callback' for module '{$this->getName()}', file '{$fileName}'.";
                $this->getLogger()->error( $msg );
                throw new LogicException( $msg );
            }
            if ( isset( $fileInfo['versionCallback'] ) ) {
                if ( !is_callable( $fileInfo['versionCallback'] ) ) {
                    throw new LogicException( "Invalid 'versionCallback' for "
                        . "module '{$this->getName()}', file '{$fileName}'."
                    );
                }
 
                // Execute the versionCallback with the same arguments that
                // would be given to the callback
                $callbackResult = ( $fileInfo['versionCallback'] )(
                    $context,
                    $this->getConfig(),
                    $expanded['callbackParam']
                );
                if ( $callbackResult instanceof FilePath ) {
                    $callbackResult->initBasePaths( $this->localBasePath, $this->remoteBasePath );
                    $expanded['versionFilePath'] = $callbackResult;
                } else {
                    $expanded['definitionSummary'] = $callbackResult;
                }
                // Don't invoke 'callback' here as it may be expensive (T223260).
                $expanded['callback'] = $fileInfo['callback'];
            } else {
                // Else go ahead invoke callback with its arguments.
                $callbackResult = ( $fileInfo['callback'] )(
                    $context,
                    $this->getConfig(),
                    $expanded['callbackParam']
                );
                if ( $callbackResult instanceof FilePath ) {
                    $callbackResult->initBasePaths( $this->localBasePath, $this->remoteBasePath );
                    $expanded['filePath'] = $callbackResult;
                } else {
                    $expanded['content'] = $callbackResult;
                }
            }
        } elseif ( isset( $fileInfo['config'] ) ) {
            if ( $type !== 'data' ) {
                $msg = "Key 'config' only valid for data files. "
                    . " Module '{$this->getName()}', file '{$fileName}' is '{$type}'.";
                $this->getLogger()->error( $msg );
                throw new LogicException( $msg );
            }
            $expandedConfig = [];
            foreach ( $fileInfo['config'] as $configKey => $var ) {
                $expandedConfig[ is_numeric( $configKey ) ? $var : $configKey ] = $this->getConfig()->get( $var );
            }
            $expanded['content'] = $expandedConfig;
        } elseif ( !empty( $fileInfo['main'] ) ) {
            // [ 'name' => 'foo.js', 'main' => true ] is shorthand
            $expanded['filePath'] = $this->makeFilePath( $fileName );
        } else {
            $msg = "Incomplete definition for module '{$this->getName()}', file '{$fileName}'. "
                . "One of 'file', 'content', 'callback', or 'config' must be set.";
            $this->getLogger()->error( $msg );
            throw new LogicException( $msg );
        }
        if ( !isset( $expanded['filePath'] ) ) {
            $expanded['virtualFilePath'] = $this->makeFilePath( $fileName );
        }
        return $expanded;
    }
 
    private function makeFilePath( $path ): FilePath {
        if ( $path instanceof FilePath ) {
            return $path;
        } elseif ( is_string( $path ) ) {
            return new FilePath( $path, $this->localBasePath, $this->remoteBasePath );
        } else {
            throw new InvalidArgumentException( '$path must be either FilePath or string' );
        }
    }
 
    public function getPackageFiles( Context $context ) {
        if ( $this->packageFiles === null ) {
            return null;
        }
        $hash = $context->getHash();
        if ( isset( $this->fullyExpandedPackageFiles[ $hash ] ) ) {
            return $this->fullyExpandedPackageFiles[ $hash ];
        }
        $expandedPackageFiles = $this->expandPackageFiles( $context ) ?? [];
 
        foreach ( $expandedPackageFiles['files'] as &$fileInfo ) {
            $this->readFileInfo( $context, $fileInfo );
        }
 
        $this->fullyExpandedPackageFiles[ $hash ] = $expandedPackageFiles;
        return $expandedPackageFiles;
    }
 
    private function readFileInfo( Context $context, array &$fileInfo ) {
        // Turn any 'filePath' or 'callback' key into actual 'content',
        // and remove the key after that. The callback could return a
        // FilePath object; if that happens, fall through to the 'filePath'
        // handling.
        if ( !isset( $fileInfo['content'] ) && isset( $fileInfo['callback'] ) ) {
            $callbackResult = ( $fileInfo['callback'] )(
                $context,
                $this->getConfig(),
                $fileInfo['callbackParam']
            );
            if ( $callbackResult instanceof FilePath ) {
                // Fall through to the filePath handling code below
                $fileInfo['filePath'] = $callbackResult;
            } else {
                $fileInfo['content'] = $callbackResult;
            }
            unset( $fileInfo['callback'] );
        }
        // Only interpret 'filePath' if 'content' hasn't been set already.
        // This can happen if 'versionCallback' provided 'filePath',
        // while 'callback' provides 'content'. In that case both are set
        // at this point. The 'filePath' from 'versionCallback' in that case is
        // only to inform getDefinitionSummary().
        if ( !isset( $fileInfo['content'] ) && isset( $fileInfo['filePath'] ) ) {
            $localPath = $this->getLocalPath( $fileInfo['filePath'] );
            $content = $this->getFileContents( $localPath, 'package' );
            if ( $fileInfo['type'] === 'data' ) {
                $content = json_decode( $content, false, 512, JSON_THROW_ON_ERROR );
            }
            $fileInfo['content'] = $content;
        }
        if ( $fileInfo['type'] === 'script-vue' ) {
            try {
                $parsedComponent = $this->getVueComponentParser()->parse(
                // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset False positive
                    $fileInfo['content'],
                    [ 'minifyTemplate' => !$context->getDebug() ]
                );
            } catch ( TimeoutException $e ) {
                throw $e;
            } catch ( Exception $e ) {
                $msg = "Error parsing file '{$fileInfo['name']}' in module '{$this->getName()}': " .
                    $e->getMessage();
                $this->getLogger()->error( $msg );
                throw new RuntimeException( $msg );
            }
            $encodedTemplate = json_encode( $parsedComponent['template'] );
            if ( $context->getDebug() ) {
                // Replace \n (backslash-n) with space + backslash-n + backslash-newline in debug mode
                // The \n has to be preserved to prevent Vue parser issues (T351771)
                // We only replace \n if not preceded by a backslash, to avoid breaking '\\n'
                $encodedTemplate = preg_replace( '/(?<!\\\\)\\\\n/', " \\n\\\n", $encodedTemplate );
                // Expand \t to real tabs in debug mode
                $encodedTemplate = strtr( $encodedTemplate, [ "\\t" => "\t" ] );
            }
            $fileInfo['content'] = [
                'script' => $parsedComponent['script'] .
                    ";\nmodule.exports.template = $encodedTemplate;",
                'style' => $parsedComponent['style'] ?? '',
                'styleLang' => $parsedComponent['styleLang'] ?? 'css'
            ];
            $fileInfo['type'] = 'script+style';
        }
        if ( !isset( $fileInfo['content'] ) ) {
            // This should not be possible due to validation in expandFileInfo()
            $msg = "Unable to resolve contents for file {$fileInfo['name']}";
            $this->getLogger()->error( $msg );
            throw new RuntimeException( $msg );
        }
 
        // Not needed for client response, exists for use by getDefinitionSummary().
        unset( $fileInfo['definitionSummary'] );
        // Not needed for client response, used by callbacks only.
        unset( $fileInfo['callbackParam'] );
    }
 
    protected function stripBom( $input ) {
        if ( str_starts_with( $input, "\xef\xbb\xbf" ) ) {
            return substr( $input, 3 );
        }
        return $input;
    }
}