ResourceLoaderImageModule.php

Go to the documentation of this file.

<?php
class ResourceLoaderImageModule extends ResourceLoaderModule {
 
    protected $definition = null;
 
    protected $localBasePath = '';
 
    protected $origin = self::ORIGIN_CORE_SITEWIDE;
 
    protected $images = [];
    protected $variants = [];
    protected $prefix = null;
    protected $selectorWithoutVariant = '.{prefix}-{name}';
    protected $selectorWithVariant = '.{prefix}-{name}-{variant}';
    protected $targets = [ 'desktop', 'mobile' ];
 
    public function __construct( $options = [], $localBasePath = null ) {
        $this->localBasePath = self::extractLocalBasePath( $options, $localBasePath );
 
        $this->definition = $options;
    }
 
    protected function loadFromDefinition() {
        if ( $this->definition === null ) {
            return;
        }
 
        $options = $this->definition;
        $this->definition = null;
 
        if ( isset( $options['data'] ) ) {
            $dataPath = $this->localBasePath . '/' . $options['data'];
            $data = json_decode( file_get_contents( $dataPath ), true );
            $options = array_merge( $data, $options );
        }
 
        // Accepted combinations:
        // * prefix
        // * selector
        // * selectorWithoutVariant + selectorWithVariant
        // * prefix + selector
        // * prefix + selectorWithoutVariant + selectorWithVariant
 
        $prefix = isset( $options['prefix'] ) && $options['prefix'];
        $selector = isset( $options['selector'] ) && $options['selector'];
        $selectorWithoutVariant = isset( $options['selectorWithoutVariant'] )
            && $options['selectorWithoutVariant'];
        $selectorWithVariant = isset( $options['selectorWithVariant'] )
            && $options['selectorWithVariant'];
 
        if ( $selectorWithoutVariant && !$selectorWithVariant ) {
            throw new InvalidArgumentException(
                "Given 'selectorWithoutVariant' but no 'selectorWithVariant'."
            );
        }
        if ( $selectorWithVariant && !$selectorWithoutVariant ) {
            throw new InvalidArgumentException(
                "Given 'selectorWithVariant' but no 'selectorWithoutVariant'."
            );
        }
        if ( $selector && $selectorWithVariant ) {
            throw new InvalidArgumentException(
                "Incompatible 'selector' and 'selectorWithVariant'+'selectorWithoutVariant' given."
            );
        }
        if ( !$prefix && !$selector && !$selectorWithVariant ) {
            throw new InvalidArgumentException(
                "None of 'prefix', 'selector' or 'selectorWithVariant'+'selectorWithoutVariant' given."
            );
        }
 
        foreach ( $options as $member => $option ) {
            switch ( $member ) {
                case 'images':
                case 'variants':
                    if ( !is_array( $option ) ) {
                        throw new InvalidArgumentException(
                            "Invalid list error. '$option' given, array expected."
                        );
                    }
                    if ( !isset( $option['default'] ) ) {
                        // Backwards compatibility
                        $option = [ 'default' => $option ];
                    }
                    foreach ( $option as $skin => $data ) {
                        if ( !is_array( $option ) ) {
                            throw new InvalidArgumentException(
                                "Invalid list error. '$option' given, array expected."
                            );
                        }
                    }
                    $this->{$member} = $option;
                    break;
 
                case 'prefix':
                case 'selectorWithoutVariant':
                case 'selectorWithVariant':
                    $this->{$member} = (string)$option;
                    break;
 
                case 'selector':
                    $this->selectorWithoutVariant = $this->selectorWithVariant = (string)$option;
            }
        }
    }
 
    public function getPrefix() {
        $this->loadFromDefinition();
        return $this->prefix;
    }
 
    public function getSelectors() {
        $this->loadFromDefinition();
        return [
            'selectorWithoutVariant' => $this->selectorWithoutVariant,
            'selectorWithVariant' => $this->selectorWithVariant,
        ];
    }
 
    public function getImage( $name, ResourceLoaderContext $context ) {
        $this->loadFromDefinition();
        $images = $this->getImages( $context );
        return isset( $images[$name] ) ? $images[$name] : null;
    }
 
    public function getImages( ResourceLoaderContext $context ) {
        $skin = $context->getSkin();
        if ( !isset( $this->imageObjects ) ) {
            $this->loadFromDefinition();
            $this->imageObjects = [];
        }
        if ( !isset( $this->imageObjects[$skin] ) ) {
            $this->imageObjects[$skin] = [];
            if ( !isset( $this->images[$skin] ) ) {
                $this->images[$skin] = isset( $this->images['default'] ) ?
                    $this->images['default'] :
                    [];
            }
            foreach ( $this->images[$skin] as $name => $options ) {
                $fileDescriptor = is_string( $options ) ? $options : $options['file'];
 
                $allowedVariants = array_merge(
                    ( is_array( $options ) && isset( $options['variants'] ) ) ? $options['variants'] : [],
                    $this->getGlobalVariants( $context )
                );
                if ( isset( $this->variants[$skin] ) ) {
                    $variantConfig = array_intersect_key(
                        $this->variants[$skin],
                        array_fill_keys( $allowedVariants, true )
                    );
                } else {
                    $variantConfig = [];
                }
 
                $image = new ResourceLoaderImage(
                    $name,
                    $this->getName(),
                    $fileDescriptor,
                    $this->localBasePath,
                    $variantConfig
                );
                $this->imageObjects[$skin][$image->getName()] = $image;
            }
        }
 
        return $this->imageObjects[$skin];
    }
 
    public function getGlobalVariants( ResourceLoaderContext $context ) {
        $skin = $context->getSkin();
        if ( !isset( $this->globalVariants ) ) {
            $this->loadFromDefinition();
            $this->globalVariants = [];
        }
        if ( !isset( $this->globalVariants[$skin] ) ) {
            $this->globalVariants[$skin] = [];
            if ( !isset( $this->variants[$skin] ) ) {
                $this->variants[$skin] = isset( $this->variants['default'] ) ?
                    $this->variants['default'] :
                    [];
            }
            foreach ( $this->variants[$skin] as $name => $config ) {
                if ( isset( $config['global'] ) && $config['global'] ) {
                    $this->globalVariants[$skin][] = $name;
                }
            }
        }
 
        return $this->globalVariants[$skin];
    }
 
    public function getStyles( ResourceLoaderContext $context ) {
        $this->loadFromDefinition();
 
        // Build CSS rules
        $rules = [];
        $script = $context->getResourceLoader()->getLoadScript( $this->getSource() );
        $selectors = $this->getSelectors();
 
        foreach ( $this->getImages( $context ) as $name => $image ) {
            $declarations = $this->getStyleDeclarations( $context, $image, $script );
            $selector = strtr(
                $selectors['selectorWithoutVariant'],
                [
                    '{prefix}' => $this->getPrefix(),
                    '{name}' => $name,
                    '{variant}' => '',
                ]
            );
            $rules[] = "$selector {\n\t$declarations\n}";
 
            foreach ( $image->getVariants() as $variant ) {
                $declarations = $this->getStyleDeclarations( $context, $image, $script, $variant );
                $selector = strtr(
                    $selectors['selectorWithVariant'],
                    [
                        '{prefix}' => $this->getPrefix(),
                        '{name}' => $name,
                        '{variant}' => $variant,
                    ]
                );
                $rules[] = "$selector {\n\t$declarations\n}";
            }
        }
 
        $style = implode( "\n", $rules );
        return [ 'all' => $style ];
    }
 
    private function getStyleDeclarations(
        ResourceLoaderContext $context,
        ResourceLoaderImage $image,
        $script,
        $variant = null
    ) {
        $imageDataUri = $image->getDataUri( $context, $variant, 'original' );
        $primaryUrl = $imageDataUri ?: $image->getUrl( $context, $script, $variant, 'original' );
        $declarations = $this->getCssDeclarations(
            $primaryUrl,
            $image->getUrl( $context, $script, $variant, 'rasterized' )
        );
        return implode( "\n\t", $declarations );
    }
 
    protected function getCssDeclarations( $primary, $fallback ) {
        $primaryUrl = CSSMin::buildUrlValue( $primary );
        $fallbackUrl = CSSMin::buildUrlValue( $fallback );
        return [
            "background-image: $fallbackUrl;",
            "background-image: linear-gradient(transparent, transparent), $primaryUrl;",
        ];
    }
 
    public function supportsURLLoading() {
        return false;
    }
 
    public function getDefinitionSummary( ResourceLoaderContext $context ) {
        $this->loadFromDefinition();
        $summary = parent::getDefinitionSummary( $context );
 
        $options = [];
        foreach ( [
            'localBasePath',
            'images',
            'variants',
            'prefix',
            'selectorWithoutVariant',
            'selectorWithVariant',
        ] as $member ) {
            $options[$member] = $this->{$member};
        };
 
        $summary[] = [
            'options' => $options,
            'fileHashes' => $this->getFileHashes( $context ),
        ];
        return $summary;
    }
 
    protected function getFileHashes( ResourceLoaderContext $context ) {
        $this->loadFromDefinition();
        $files = [];
        foreach ( $this->getImages( $context ) as $name => $image ) {
            $files[] = $image->getPath( $context );
        }
        $files = array_values( array_unique( $files ) );
        return array_map( [ __CLASS__, 'safeFileHash' ], $files );
    }
 
    public static function extractLocalBasePath( $options, $localBasePath = null ) {
        global $IP;
 
        if ( $localBasePath === null ) {
            $localBasePath = $IP;
        }
 
        if ( array_key_exists( 'localBasePath', $options ) ) {
            $localBasePath = (string)$options['localBasePath'];
        }
 
        return $localBasePath;
    }
 
    public function getType() {
        return self::LOAD_STYLES;
    }
}