Class luya\web\AssetManager

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function checkBasePathPermission()
{
    // if the check is been done already, skip further checks
    if ($this->_isBasePathPermissionChecked) {
        return;
    }
    if (!is_dir($this->basePath)) {
        throw new InvalidConfigException("The directory does not exist: {$this->basePath}");
    }
    if (!is_writable($this->basePath)) {
        throw new InvalidConfigException("The directory is not writable by the Web process: {$this->basePath}");
    }
    $this->_isBasePathPermissionChecked = true;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function getActualAssetUrl($bundle, $asset)
{
    if (($actualAsset = $this->resolveAsset($bundle, $asset)) !== false) {
        if (strncmp($actualAsset, '@web/', 5) === 0) {
            $asset = substr($actualAsset, 5);
            $baseUrl = Yii::getAlias('@web');
        } else {
            $asset = Yii::getAlias($actualAsset);
            $baseUrl = $this->baseUrl;
        }
    } else {
        $baseUrl = $bundle->baseUrl;
    }
    if (!Url::isRelative($asset) || strncmp($asset, '/', 1) === 0) {
        return $asset;
    }
    return "$baseUrl/$asset";
}

            

                public function getAssetPath($bundle, $asset)
{
    if (($actualAsset = $this->resolveAsset($bundle, $asset)) !== false) {
        return Url::isRelative($actualAsset) ? $this->basePath . '/' . $actualAsset : false;
    }
    return Url::isRelative($asset) ? $bundle->basePath . '/' . $asset : false;
}

            

                public function getAssetUrl($bundle, $asset, $appendTimestamp = null)
{
    $assetUrl = $this->getActualAssetUrl($bundle, $asset);
    $assetPath = $this->getAssetPath($bundle, $asset);
    $withTimestamp = $this->appendTimestamp;
    if ($appendTimestamp !== null) {
        $withTimestamp = $appendTimestamp;
    }
    if ($withTimestamp && $assetPath && ($timestamp = @filemtime($assetPath)) > 0) {
        return "$assetUrl?v=$timestamp";
    }
    return $assetUrl;
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getBundle($name, $publish = true)
{
    if ($this->bundles === false) {
        return $this->loadDummyBundle($name);
    } elseif (!isset($this->bundles[$name])) {
        return $this->bundles[$name] = $this->loadBundle($name, [], $publish);
    } elseif ($this->bundles[$name] instanceof AssetBundle) {
        return $this->bundles[$name];
    } elseif (is_array($this->bundles[$name])) {
        return $this->bundles[$name] = $this->loadBundle($name, $this->bundles[$name], $publish);
    } elseif ($this->bundles[$name] === false) {
        return $this->loadDummyBundle($name);
    }
    throw new InvalidConfigException("Invalid asset bundle configuration: $name");
}

            

                public function getConverter()
{
    if ($this->_converter === null) {
        $this->_converter = Yii::createObject(AssetConverter::className());
    } elseif (is_array($this->_converter) || is_string($this->_converter)) {
        if (is_array($this->_converter) && !isset($this->_converter['class'])) {
            $this->_converter['class'] = AssetConverter::className();
        }
        $this->_converter = Yii::createObject($this->_converter);
    }
    return $this->_converter;
}

            

                public function getPublishedPath($path)
{
    $path = Yii::getAlias($path);
    if (isset($this->_published[$path])) {
        return $this->_published[$path][0];
    }
    if (is_string($path) && ($path = realpath($path)) !== false) {
        return $this->basePath . DIRECTORY_SEPARATOR . $this->hash($path) . (is_file($path) ? DIRECTORY_SEPARATOR . basename($path) : '');
    }
    return false;
}

            

                public function getPublishedUrl($path)
{
    $path = Yii::getAlias($path);
    if (isset($this->_published[$path])) {
        return $this->_published[$path][1];
    }
    if (is_string($path) && ($path = realpath($path)) !== false) {
        return $this->baseUrl . '/' . $this->hash($path) . (is_file($path) ? '/' . basename($path) : '');
    }
    return false;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                protected function hash($path)
{
    if (is_callable($this->hashCallback)) {
        return call_user_func($this->hashCallback, $path);
    }
    $path = (is_file($path) ? dirname($path) : $path) . filemtime($path);
    return sprintf('%x', crc32($path . Yii::getVersion() . '|' . $this->linkAssets));
}

            

                public function init()
{
    parent::init();
    $this->basePath = Yii::getAlias($this->basePath);
    $this->basePath = realpath($this->basePath);
    $this->baseUrl = rtrim(Yii::getAlias($this->baseUrl), '/');
}

            

                protected function loadBundle($name, $config = [], $publish = true)
{
    if (!isset($config['class'])) {
        $config['class'] = $name;
    }
    /* @var $bundle AssetBundle */
    $bundle = Yii::createObject($config);
    if ($publish) {
        $bundle->publish($this);
    }
    return $bundle;
}

            

                protected function loadDummyBundle($name)
{
    if (!isset($this->_dummyBundles[$name])) {
        $bundle = Yii::createObject(['class' => $name]);
        $bundle->sourcePath = null;
        $bundle->js = [];
        $bundle->css = [];
        $this->_dummyBundles[$name] = $bundle;
    }
    return $this->_dummyBundles[$name];
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function publish($path, $options = [])
{
    $path = Yii::getAlias($path);
    if (isset($this->_published[$path])) {
        return $this->_published[$path];
    }
    if (!is_string($path) || ($src = realpath($path)) === false) {
        throw new InvalidArgumentException("The file or directory to be published does not exist: $path");
    }
    if (!is_readable($path)) {
        throw new InvalidArgumentException("The file or directory to be published is not readable: $path");
    }
    if (is_file($src)) {
        return $this->_published[$path] = $this->publishFile($src);
    }
    return $this->_published[$path] = $this->publishDirectory($src, $options);
}

            

                protected function publishDirectory($src, $options)
{
    $this->checkBasePathPermission();
    $dir = $this->hash($src);
    $dstDir = $this->basePath . DIRECTORY_SEPARATOR . $dir;
    if ($this->linkAssets) {
        if (!is_dir($dstDir)) {
            FileHelper::createDirectory(dirname($dstDir), $this->dirMode, true);
            try { // fix #6226 symlinking multi threaded
                symlink($src, $dstDir);
            } catch (\Exception $e) {
                if (!is_dir($dstDir)) {
                    throw $e;
                }
            }
        }
    } elseif (!empty($options['forceCopy']) || ($this->forceCopy && !isset($options['forceCopy'])) || !is_dir($dstDir)) {
        $opts = array_merge(
            $options,
            [
                'dirMode' => $this->dirMode,
                'fileMode' => $this->fileMode,
                'copyEmptyDirectories' => false,
            ]
        );
        if (!isset($opts['beforeCopy'])) {
            if ($this->beforeCopy !== null) {
                $opts['beforeCopy'] = $this->beforeCopy;
            } else {
                $opts['beforeCopy'] = function ($from, $to) {
                    return strncmp(basename($from), '.', 1) !== 0;
                };
            }
        }
        if (!isset($opts['afterCopy']) && $this->afterCopy !== null) {
            $opts['afterCopy'] = $this->afterCopy;
        }
        FileHelper::copyDirectory($src, $dstDir, $opts);
    }
    return [$dstDir, $this->baseUrl . '/' . $dir];
}

            

                protected function publishFile($src)
{
    $this->checkBasePathPermission();
    $dir = $this->hash($src);
    $fileName = basename($src);
    $dstDir = $this->basePath . DIRECTORY_SEPARATOR . $dir;
    $dstFile = $dstDir . DIRECTORY_SEPARATOR . $fileName;
    if (!is_dir($dstDir)) {
        FileHelper::createDirectory($dstDir, $this->dirMode, true);
    }
    if ($this->linkAssets) {
        if (!is_file($dstFile)) {
            try { // fix #6226 symlinking multi threaded
                symlink($src, $dstFile);
            } catch (\Exception $e) {
                if (!is_file($dstFile)) {
                    throw $e;
                }
            }
        }
    } elseif (@filemtime($dstFile) < @filemtime($src)) {
        copy($src, $dstFile);
        if ($this->fileMode !== null) {
            @chmod($dstFile, $this->fileMode);
        }
    }
    if ($this->appendTimestamp && ($timestamp = @filemtime($dstFile)) > 0) {
        $fileName = $fileName . "?v=$timestamp";
    }
    return [$dstFile, $this->baseUrl . "/$dir/$fileName"];
}

            

                protected function resolveAsset($bundle, $asset)
{
    if (isset($this->assetMap[$asset])) {
        return $this->assetMap[$asset];
    }
    if ($bundle->sourcePath !== null && Url::isRelative($asset)) {
        $asset = $bundle->sourcePath . '/' . $asset;
    }
    $n = mb_strlen($asset, Yii::$app->charset);
    foreach ($this->assetMap as $from => $to) {
        $n2 = mb_strlen($from, Yii::$app->charset);
        if ($n2 <= $n && substr_compare($asset, $from, $n - $n2, $n2) === 0) {
            return $to;
        }
    }
    return false;
}

            

                public function setConverter($value)
{
    $this->_converter = $value;
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}