asset.php

<?php
 
namespace Bitrix\Main\Web\WebPacker\Resource;
 
use Bitrix\Main\Application;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\IO;
use Bitrix\Main\Web\WebPacker;
 
abstract class Asset
{
    const JS = 'js';
    const CSS = 'css';
    const LAYOUT = 'layout';
    const LANG = 'lang';
 
    protected $type;
    protected $path;
    protected $uri;
    protected $content;
 
    public static function create($path)
    {
        $type = self::detectType($path);
        switch ($type)
        {
            case self::LANG:
                return new LangAsset($path);
            case self::JS:
                return new JsAsset($path);
            case self::CSS:
                return new CssAsset($path);
            case self::LAYOUT:
                return new LayoutAsset($path);
            default:
                throw new ArgumentException("Unknown type `$type`.");
        }
    }
 
    public static function getTypeList()
    {
        return [self::JS, self::CSS, self::LAYOUT, self::LANG];
    }
 
    public static function detectType($path)
    {
        $type = mb_strtolower(mb_substr(strrchr($path, '.'), 1));
        switch ($type)
        {
            case 'js':
                return self::JS;
            case 'css':
                return self::CSS;
            case 'htm':
            case 'html':
                return self::LAYOUT;
            case 'php':
                return self::LANG;
            default:
                return null;
        }
    }
 
    public function __construct($path = null)
    {
        if ($path)
        {
            $this->setPath($path);
        }
    }
 
    public function getType()
    {
        return $this->type;
    }
 
    public function getPath()
    {
        return $this->path;
    }
 
    public function setPath($path)
    {
        if (!static::isExists($path))
        {
            throw new ArgumentException("Can not locate file by path `{$path}`.");
        }
 
        if (self::detectType($path) != $this->getType())
        {
            throw new ArgumentException("Path has wrong ext of `$path` for Asset with type `{$this->getType()}`.");
        }
 
        $this->path = $path;
 
        return $this;
    }
 
    public function getUri()
    {
        if ($this->uri)
        {
            return $this->uri;
        }
 
        return $this->path ?
            WebPacker\Builder::getDefaultSiteUri()
                . $this->path
                . '?' . filemtime(self::getAbsolutePath($this->path))
                . '.' . filesize(self::getAbsolutePath($this->path))
            :
            null;
    }
 
    public function setUri($uri)
    {
        $this->uri = $uri;
        return $this;
    }
 
    public function setContent($content)
    {
        $this->content = $content;
        return $this;
    }
 
    public function getName()
    {
        return $this->path ? basename($this->path) : null;
    }
 
    public function getContent()
    {
        if ($this->content)
        {
            return $this->content;
        }
 
        if (!static::isExists($this->path))
        {
            return null;
        }
 
        $path = self::getAbsolutePath($this->path);
 
        $mapPath = null;
        $useMinimized = false;
        $minPathPos = mb_strrpos($path, '.');
        if ($minPathPos !== false)
        {
            $minPath = mb_substr($path, 0, $minPathPos)
                .'.min'
                .mb_substr($path, $minPathPos);
 
            if (IO\File::isFileExists($minPath))
            {
                $path = $minPath;
                $useMinimized = true;
 
                $minPathPos = mb_strrpos($this->path, '.');
                $mapPath = mb_substr($this->path, 0, $minPathPos)
                    .'.map'
                    .mb_substr($this->path, $minPathPos);
            }
        }
 
        $content = IO\File::getFileContents($path) ?: '';
        if (!$content || !$useMinimized || !$mapPath)
        {
            return $content;
        }
 
        $parts = explode("\n", $content);
        $mapUri = '//# sourceMappingURL=';
        if (mb_strpos(array_pop($parts), $mapUri) !== 0)
        {
            return $content;
        }
 
        $mapUri .=  WebPacker\Builder::getDefaultSiteUri() . $mapPath;
        array_push($parts, $mapUri);
 
        return implode("\n", $parts);
 
    }
 
    public static function isExists($path)
    {
        return $path ? IO\File::isFileExists(self::getAbsolutePath($path)) : false;
    }
 
    protected static function getAbsolutePath($path)
    {
        return $path ? Application::getDocumentRoot() . $path : null;
    }
}