views.php

Go to the documentation of this file.

<?php
use Elgg\Exceptions\Http\PageNotFoundException;
use Elgg\Exceptions\InvalidArgumentException as ElggInvalidArgumentException;
use Elgg\Menu\Menu;
use Elgg\Menu\UnpreparedMenu;

function elgg_set_viewtype($viewtype = '') {
    return _elgg_services()->views->setViewtype($viewtype);
}

function elgg_get_viewtype() {
    return _elgg_services()->views->getViewtype();
}

function elgg_register_viewtype_fallback($viewtype) {
    _elgg_services()->views->registerViewtypeFallback($viewtype);
}

function elgg_register_ajax_view($view) {
    elgg_register_external_view($view, false);
}

function elgg_unregister_ajax_view($view) {
    elgg_unregister_external_view($view);
}

function elgg_register_external_view($view, $cacheable = false) {

    _elgg_services()->ajax->registerView($view);

    if ($cacheable) {
        _elgg_services()->views->registerCacheableView($view);
    }
}

function elgg_unregister_external_view($view) {
    _elgg_services()->ajax->unregisterView($view);
}

function elgg_set_view_location($view, $location, $viewtype = '') {
    _elgg_services()->views->setViewDir($view, $location, $viewtype);
}

function elgg_view_exists($view, $viewtype = '', $recurse = true) {
    return _elgg_services()->views->viewExists($view, $viewtype, $recurse);
}

function elgg_view($view, $vars = [], $viewtype = '') {
    if (func_num_args() == 5) {
        elgg_log(__FUNCTION__ . ' now has only 3 arguments. Update your usage.', 'ERROR');
        $viewtype = func_get_arg(4);
    }
    return _elgg_services()->views->renderView($view, $vars, $viewtype);
}

function elgg_extend_view($view, $view_extension, $priority = 501) {
    _elgg_services()->views->extendView($view, $view_extension, $priority);
}

function elgg_unextend_view($view, $view_extension) {
    return _elgg_services()->views->unextendView($view, $view_extension);
}

function elgg_get_view_extensions($view) {
    $list = _elgg_services()->views->getViewList($view);
    unset($list[500]);
    return $list;
}

function elgg_view_page($title, $body, $page_shell = 'default', $vars = []) {
    
    if (elgg_is_xhr() && get_input('_elgg_ajax_list')) {
        // requested by ajaxed pagination
        return is_array($body) ? elgg_extract('content', $body) : $body;
    }
    
    if (is_array($body)) {
        $vars['entity'] = elgg_extract('entity', $body, elgg_extract('entity', $vars));

        $body['title'] = elgg_extract('title', $body, $title);
        $body = elgg_view_layout('default', $body);
    }
    
    $timer = _elgg_services()->timer;
    if (!$timer->hasEnded(['build page'])) {
        $timer->end(['build page']);
    }
    $timer->begin([__FUNCTION__]);

    $params = [];
    $params['identifier'] = _elgg_services()->request->getFirstUrlSegment();
    $params['segments'] = _elgg_services()->request->getUrlSegments();
    array_shift($params['segments']);
    $page_shell = elgg_trigger_plugin_hook('shell', 'page', $params, $page_shell);


    $system_messages = _elgg_services()->system_messages;

    $messages = null;
    if ($system_messages->count()) {
        $messages = $system_messages->dumpRegister();

        if (isset($messages['error'])) {
            // always make sure error is the first type
            $errors = [
                'error' => $messages['error']
            ];

            unset($messages['error']);
            $messages = array_merge($errors, $messages);
        }
    }

    $vars['title'] = $title;
    $vars['body'] = $body;
    $vars['sysmessages'] = $messages;
    $vars['page_shell'] = $page_shell;

    $vars['head'] = elgg_trigger_plugin_hook('head', 'page', $vars, ['metas' => [], 'links' => []]);

    $vars = elgg_trigger_plugin_hook('output:before', 'page', null, $vars);

    $output = elgg_view("page/$page_shell", $vars);


    // Allow plugins to modify the output
    $output = elgg_trigger_plugin_hook('output', 'page', $vars, $output);

    $timer->end([__FUNCTION__]);
    return $output;
}

function elgg_view_resource($name, array $vars = []) {
    $view = "resources/$name";

    if (elgg_view_exists($view)) {
        return _elgg_services()->views->renderView($view, $vars);
    }

    if (elgg_get_viewtype() !== 'default' && elgg_view_exists($view, 'default')) {
        return _elgg_services()->views->renderView($view, $vars, 'default');
    }

    _elgg_services()->logger->error("The view $view is missing.");

    // only works for default viewtype
    throw new PageNotFoundException();
}

function elgg_view_layout($layout_name, $vars = []) {
    $timer = _elgg_services()->timer;
    if (!$timer->hasEnded(['build page'])) {
        $timer->end(['build page']);
    }
    $timer->begin([__FUNCTION__]);
    
    $vars['identifier'] = _elgg_services()->request->getFirstUrlSegment();
    $vars['segments'] = _elgg_services()->request->getUrlSegments();
    array_shift($vars['segments']);

    $layout_name = elgg_trigger_plugin_hook('layout', 'page', $vars, $layout_name);

    $vars['layout'] = $layout_name;

    $layout_views = [
        "page/layouts/$layout_name",
        "page/layouts/default",
    ];

    $output = '';
    foreach ($layout_views as $layout_view) {
        if (elgg_view_exists($layout_view)) {
            $output = elgg_view($layout_view, $vars);
            break;
        }
    }

    $timer->end([__FUNCTION__]);
    return $output;
}

function elgg_view_menu($menu, array $vars = []) {

    $menu_view = elgg_extract('menu_view', $vars);
    unset($vars['menu_view']);

    if (is_string($menu)) {
        $menu = _elgg_services()->menus->getMenu($menu, $vars);
    } elseif ($menu instanceof UnpreparedMenu) {
        $menu = _elgg_services()->menus->prepareMenu($menu);
    }

    if (!$menu instanceof Menu) {
        throw new ElggInvalidArgumentException('$menu must be a menu name, a Menu, or UnpreparedMenu');
    }

    $name = $menu->getName();
    $params = $menu->getParams();

    $views = [
        $menu_view,
        "navigation/menu/$name",
        'navigation/menu/default',
    ];

    foreach ($views as $view) {
        if (elgg_view_exists($view)) {
            return elgg_view($view, $params);
        }
    }
}

function elgg_view_entity(\ElggEntity $entity, array $vars = []) {

    $defaults = [
        'full_view' => true,
    ];

    $vars = array_merge($defaults, $vars);
    
    if (elgg_extract('register_rss_link', $vars, elgg_extract('full_view', $vars))) {
        elgg_register_rss_link();
    }

    $vars['entity'] = $entity;

    $entity_type = $entity->getType();
    $entity_subtype = $entity->getSubtype();

    $entity_views = [
        elgg_extract('item_view', $vars, ''),
        "$entity_type/$entity_subtype",
        "$entity_type/default",
    ];

    $contents = '';
    foreach ($entity_views as $view) {
        if (elgg_view_exists($view)) {
            $contents = elgg_view($view, $vars);
            break;
        }
    }

    return $contents;
}

function elgg_view_entity_icon(\ElggEntity $entity, $size = 'medium', $vars = []) {

    $vars['entity'] = $entity;
    $vars['size'] = $size;

    $entity_type = $entity->getType();

    $subtype = $entity->getSubtype();

    $contents = '';
    if (elgg_view_exists("icon/$entity_type/$subtype")) {
        $contents = elgg_view("icon/$entity_type/$subtype", $vars);
    }
    if (empty($contents) && elgg_view_exists("icon/$entity_type/default")) {
        $contents = elgg_view("icon/$entity_type/default", $vars);
    }
    if (empty($contents)) {
        $contents = elgg_view("icon/default", $vars);
    }

    return $contents;
}

function elgg_view_annotation(\ElggAnnotation $annotation, array $vars = []) {
    $defaults = [
        'full_view' => true,
    ];

    $vars = array_merge($defaults, $vars);
    $vars['annotation'] = $annotation;

    $name = $annotation->name;
    if (empty($name)) {
        return false;
    }

    $annotation_views = [
        elgg_extract('item_view', $vars, ''),
        "annotation/$name",
        "annotation/default",
    ];

    $contents = '';
    foreach ($annotation_views as $view) {
        if (elgg_view_exists($view)) {
            $contents = elgg_view($view, $vars);
            break;
        }
    }

    return $contents;
}

function elgg_view_entity_list($entities, array $vars = []) {
    $offset = (int) get_input('offset', 0);

    // list type can be passed as request parameter
    $list_type = get_input('list_type', 'list');

    $defaults = [
        'items' => $entities,
        'list_class' => 'elgg-list-entity',
        'full_view' => true,
        'pagination' => true,
        'list_type' => $list_type,
        'offset' => $offset,
        'limit' => null,
    ];

    $vars = array_merge($defaults, $vars);

    if (!$vars["limit"] && !$vars["offset"]) {
        // no need for pagination if listing is unlimited
        $vars["pagination"] = false;
    }

    $view = "page/components/{$vars['list_type']}";
    if (!elgg_view_exists($view)) {
        $view = 'page/components/list';
    }
    
    return elgg_view($view, $vars);
}

function elgg_view_annotation_list($annotations, array $vars = []) {
    // list type can be passed as request parameter
    $list_type = get_input('list_type', 'list');

    $defaults = [
        'items' => $annotations,
        'offset' => null,
        'limit' => null,
        'list_class' => 'elgg-list-annotation',
        'full_view' => true,
        'list_type' => $list_type,
        'offset_key' => 'annoff',
    ];

    $vars = array_merge($defaults, $vars);

    if (!$vars["limit"] && !$vars["offset"]) {
        // no need for pagination if listing is unlimited
        $vars["pagination"] = false;
    }

    $view = "page/components/{$vars['list_type']}";
    if (!elgg_view_exists($view)) {
        $view = 'page/components/list';
    }
    
    return elgg_view($view, $vars);
}

function elgg_view_relationship_list($relationships, array $vars = []) {
    // list type can be passed as request parameter
    $list_type = get_input('list_type', 'list');

    $defaults = [
        'items' => $relationships,
        'offset' => null,
        'limit' => null,
        'list_class' => 'elgg-list-relationship',
        'full_view' => false,
        'list_type' => $list_type,
        'offset_key' => 'reloff',
    ];
    
    $vars = array_merge($defaults, $vars);
    
    if (!$vars['limit'] && !$vars['offset']) {
        // no need for pagination if listing is unlimited
        $vars['pagination'] = false;
    }
    
    $view = "page/components/{$vars['list_type']}";
    if (!elgg_view_exists($view)) {
        $view = 'page/components/list';
    }
    
    return elgg_view($view, $vars);
}

function elgg_view_relationship(\ElggRelationship $relationship, array $vars = []) {
    $defaults = [
        'full_view' => true,
    ];
    
    $vars = array_merge($defaults, $vars);
    $vars['relationship'] = $relationship;
    
    $name = $relationship->relationship;
    if (empty($name)) {
        return false;
    }
    
    $relationship_views = [
        elgg_extract('item_view', $vars, ''),
        "relationship/$name",
        "relationship/default",
    ];
    
    $contents = '';
    foreach ($relationship_views as $view) {
        if (elgg_view_exists($view)) {
            $contents = elgg_view($view, $vars);
            break;
        }
    }
    
    return $contents;
}

function elgg_view_title($title, array $vars = []) {
    $vars['title'] = $title;

    return elgg_view('page/elements/title', $vars);
}

function elgg_view_friendly_time($time, $time_updated = null) {
    $view = 'output/friendlytime';
    $vars = [
        'time' => $time,
        'time_updated' => $time_updated,
    ];
    $viewtype = elgg_view_exists($view) ? '' : 'default';

    return _elgg_view_under_viewtype($view, $vars, $viewtype);
}

function elgg_view_comments($entity, $add_comment = true, array $vars = []) {
    
    if (!$entity instanceof \ElggEntity) {
        return false;
    }
    
    if (!$entity->hasCapability('commentable')) {
        return false;
    }

    $vars['entity'] = $entity;
    $vars['show_add_form'] = $add_comment;
    $vars['class'] = elgg_extract('class', $vars, "{$entity->getSubtype()}-comments");

    $output = elgg_trigger_plugin_hook('comments', $entity->getType(), $vars, false);
    if ($output !== false) {
        return $output;
    }
    
    return elgg_view('page/elements/comments', $vars);
}

function elgg_view_image_block($image, $body, $vars = []) {
    $vars['image'] = $image;
    $vars['body'] = $body;
    return elgg_view('page/components/image_block', $vars);
}

function elgg_view_module($type, $title, $body, array $vars = []) {
    $vars['type'] = $type;
    $vars['title'] = $title;
    $vars['body'] = $body;
    return elgg_view('page/components/module', $vars);
}

function elgg_view_message($type, $body, array $vars = []) {
    $vars['type'] = $type;
    $vars['body'] = $body;
    return elgg_view('page/components/message', $vars);
}

function elgg_view_river_item($item, array $vars = []) {

    if (!($item instanceof \ElggRiverItem)) {
        return '';
    }

    // checking default viewtype since some viewtypes do not have unique views per item (rss)
    $view = $item->getView();

    $subject = $item->getSubjectEntity();
    $object = $item->getObjectEntity();
    if (!$subject || !$object) {
        // subject is disabled or subject/object deleted
        return '';
    }
    
    if (elgg_extract('register_rss_link', $vars)) {
        elgg_register_rss_link();
    }

    $vars['item'] = $item;

    // create river view logic
    $type = $object->getType();
    $subtype = $object->getSubtype();
    $action = $item->action_type;

    $river_views = [
        elgg_extract('item_view', $vars, ''),
        'river/item', // important for other viewtypes, e.g. "rss"
        $view,
        "river/{$type}/{$subtype}/{$action}",
        "river/{$type}/{$subtype}/default",
        "river/{$type}/{$action}",
        "river/{$type}/default",
        'river/elements/layout',
    ];

    $contents = '';
    foreach ($river_views as $view) {
        if (elgg_view_exists($view)) {
            $contents = elgg_view($view, $vars);
            break;
        }
    }

    return $contents;
}

function elgg_view_form($action, $form_vars = [], $body_vars = []) {
    return _elgg_services()->forms->render($action, $form_vars, $body_vars);
}

function elgg_set_form_footer($footer = '') {
    return _elgg_services()->forms->setFooter($footer);
}

function elgg_get_form_footer() {
    return _elgg_services()->forms->getFooter();
}

function _elgg_split_vars(array $vars = [], array $prefixes = null) {

    if (!isset($prefixes)) {
        $prefixes = ['#'];
    }

    $return = [];
    $default_section = ''; // something weird with PHP 8.1 compatibility
    
    foreach ($vars as $key => $value) {
        foreach ($prefixes as $prefix) {
            if (substr($key, 0, 1) === $prefix) {
                $key = substr($key, 1);
                $return[$prefix][$key] = $value;
                break;
            } else {
                $return[$default_section][$key] = $value;
            }
        }
    }

    return $return;
}

function elgg_view_field(array $params = []) {

    if (!empty($params['#html'])) {
        return $params['#html'];
    }
    
    if (empty($params['#type'])) {
        _elgg_services()->logger->error(__FUNCTION__ . '(): $params["#type"] is required.');
        return '';
    }

    $input_type = $params['#type'];
    if (!elgg_view_exists("input/$input_type")) {
        return '';
    }

    $hidden_types = ['hidden', 'securitytoken'];
    if (in_array($input_type, $hidden_types)) {
        $params = _elgg_split_vars($params);
        return elgg_view("input/$input_type", $params['']);
    }

    $id = elgg_extract('id', $params);
    if (!$id) {
        $id = "elgg-field-" . base_convert(mt_rand(), 10, 36);
        $params['id'] = $id;
    }

    $make_special_checkbox_label = false;
    if ($input_type == 'checkbox' && (isset($params['label']) || isset($params['#label']))) {
        if (isset($params['#label']) && isset($params['label'])) {
            $params['label_tag'] = 'div';
        } else {
            $label = elgg_extract('label', $params);
            $label = elgg_extract('#label', $params, $label);

            $params['#label'] = $label;
            unset($params['label']);

            // Single checkbox input view gets special treatment
            // We don't want the field label to appear a checkbox without a label
            $make_special_checkbox_label = true;
        }
    }

    // Need to set defaults to prevent input keys with same name ending up in element vars if not provided
    $defaults = [
        '#class' => ELGG_ENTITIES_ANY_VALUE,
        '#help' => ELGG_ENTITIES_ANY_VALUE,
        '#label' => ELGG_ENTITIES_ANY_VALUE,
        '#view' => ELGG_ENTITIES_ANY_VALUE,
    ];
    $params = array_merge($defaults, $params);
    
    // first pass non-hash keys into both
    $split_params = _elgg_split_vars($params);

    // $vars passed to input/$input_name
    $input_vars = $split_params[''];
    
    // $vars passed to label, help and field wrapper views
    $element_vars = array_merge($split_params[''], $split_params['#']);

    // field input view needs this
    $input_vars['input_type'] = $input_type;

    // field views get more data
    $element_vars['input_type'] = $input_type;

    // wrap if present
    $element_vars['label'] = elgg_view('elements/forms/label', $element_vars);
    $element_vars['help'] = elgg_view('elements/forms/help', $element_vars);

    if ($make_special_checkbox_label) {
        $input_vars['label'] = $element_vars['label'];
        $input_vars['label_tag'] = 'div';
        unset($element_vars['label']);
    }
    $element_vars['input'] = elgg_view("elements/forms/input", $input_vars);

    return elgg_view('elements/forms/field', $element_vars);
}

function elgg_view_tagcloud(array $options = []) {

    $type = $subtype = '';
    if (isset($options['type'])) {
        $type = $options['type'];
    }
    if (isset($options['subtype'])) {
        $subtype = $options['subtype'];
    }

    $tag_data = elgg_get_tags($options);
    return elgg_view("output/tagcloud", [
        'value' => $tag_data,
        'type' => $type,
        'subtype' => $subtype,
    ]);
}

function elgg_view_list_item($item, array $vars = []) {

    if ($item instanceof \ElggEntity) {
        return elgg_view_entity($item, $vars);
    } else if ($item instanceof \ElggAnnotation) {
        return elgg_view_annotation($item, $vars);
    } else if ($item instanceof \ElggRiverItem) {
        return elgg_view_river_item($item, $vars);
    } else if ($item instanceof ElggRelationship) {
        return elgg_view_relationship($item, $vars);
    }

    $view = elgg_extract('item_view', $vars);
    if ($view && elgg_view_exists($view)) {
        $vars['item'] = $item;
        return elgg_view($view, $vars);
    }

    return '';
}

function elgg_view_icon($name, $vars = []) {
    if (empty($vars)) {
        $vars = [];
    }

    if (is_string($vars)) {
        $vars = ['class' => $vars];
    }

    if (!is_array($vars)) {
        throw new ElggInvalidArgumentException('$vars needs to be a string or an array');
    }

    $vars['class'] = elgg_extract_class($vars, "elgg-icon-$name");

    return elgg_view('output/icon', $vars);
}

function elgg_register_rss_link() {
    _elgg_services()->config->_elgg_autofeed = true;
}

function elgg_unregister_rss_link() {
    _elgg_services()->config->_elgg_autofeed = false;
}

function _elgg_has_rss_link() {
    if (_elgg_services()->config->disable_rss) {
        return false;
    }

    return (bool) _elgg_services()->config->_elgg_autofeed;
}

function elgg_views_boot() {
    _elgg_services()->viewCacher->registerCoreViews();

    // jQuery and UI must come before require. See #9024
    elgg_register_external_file('js', 'jquery', elgg_get_simplecache_url('jquery.js'));
    elgg_load_external_file('js', 'jquery');

    elgg_extend_view('require.js', 'elgg/require_config.js', 100);

    elgg_register_external_file('js', 'require', elgg_get_simplecache_url('require.js'));
    elgg_load_external_file('js', 'require');

    elgg_register_external_file('js', 'elgg', elgg_get_simplecache_url('elgg.js'));
    elgg_load_external_file('js', 'elgg');

    elgg_register_external_file('css', 'font-awesome', elgg_get_simplecache_url('font-awesome/css/all.min.css'));
    elgg_load_external_file('css', 'font-awesome');

    elgg_define_js('cropperjs', [
        'src' => elgg_get_simplecache_url('cropperjs/cropper.min.js'),
    ]);
    elgg_define_js('jquery-cropper/jquery-cropper', [
        'src' => elgg_get_simplecache_url('jquery-cropper/jquery-cropper.min.js'),
    ]);

    elgg_require_css('elgg');

    elgg_extend_view('initialize_elgg.js', 'elgg/prevent_clicks.js', 1);

    elgg_extend_view('elgg.css', 'lightbox/elgg-colorbox-theme/colorbox.css');
    elgg_extend_view('elgg.css', 'entity/edit/icon/crop.css');

    elgg_define_js('jquery.ui.autocomplete.html', [
        'deps' => ['jquery-ui/widgets/autocomplete'],
    ]);

    elgg_register_simplecache_view('elgg/touch_punch.js');
    elgg_define_js('jquery-ui/widgets/sortable', [
        'deps' => ['elgg/touch_punch'],
    ]);

    elgg_register_ajax_view('languages.js');
}

function _elgg_get_js_site_data() {
    
    $message_delay = (int) elgg_get_config('message_delay');
    if ($message_delay < 1) {
        $message_delay = 6;
    }
    
    return [
        'elgg.data' => (object) elgg_trigger_plugin_hook('elgg.data', 'site', null, []),
        'elgg.release' => elgg_get_release(),
        'elgg.config.wwwroot' => elgg_get_site_url(),
        'elgg.config.message_delay' => $message_delay * 1000,

        // refresh token 3 times during its lifetime (in microseconds 1000 * 1/3)
        'elgg.security.interval' => (int) _elgg_services()->csrf->getActionTokenTimeout() * 333,
        'elgg.config.language' => _elgg_services()->config->language ?: 'en',
    ];
}

function _elgg_get_js_page_data() {
    $data = elgg_trigger_plugin_hook('elgg.data', 'page', null, []);
    if (!is_array($data)) {
        elgg_log('"elgg.data" plugin hook handlers must return an array. Returned ' . gettype($data) . '.', 'ERROR');
        $data = [];
    }

    $elgg = [
        'config' => [
            'lastcache' => (int) _elgg_services()->config->lastcache,
            'viewtype' => elgg_get_viewtype(),
            'simplecache_enabled' => (int) elgg_is_simplecache_enabled(),
            'current_language' => get_current_language(),
        ],
        'security' => [
            'token' => [
                '__elgg_ts' => $ts = _elgg_services()->csrf->getCurrentTime()->getTimestamp(),
                '__elgg_token' => _elgg_services()->csrf->generateActionToken($ts),
            ],
        ],
        'session' => [
            'user' => null,
            'token' => _elgg_services()->session->get('__elgg_session'),
        ],
        '_data' => (object) $data,
    ];

    $page_owner = elgg_get_page_owner_entity();
    if ($page_owner instanceof ElggEntity) {
        $elgg['page_owner'] = $page_owner->toObject(); // @todo remove in Elgg 5.0
    }

    $user = elgg_get_logged_in_user_entity();
    if ($user instanceof ElggUser) {
        $user_object = $user->toObject();
        $user_object->admin = $user->isAdmin();
        $elgg['session']['user'] = $user_object; // @todo remove in Elgg 5.0
        
        $elgg['user'] = (array) $user_object;
    }

    return $elgg;
}

function _elgg_view_under_viewtype($view, $vars, $viewtype) {
    $current_view_type = null;
    if ($viewtype) {
        $current_view_type = elgg_get_viewtype();
        elgg_set_viewtype($viewtype);
    }

    $ret = elgg_view($view, $vars);

    if (isset($current_view_type)) {
        elgg_set_viewtype($current_view_type);
    }

    return $ret;
}

function _elgg_map_icon_glyph_class(array $classes) {
    $common_icons = [
        'delete-alt' => 'times-circle',
        'delete' => 'times',
        'grid' => 'th',
        'info' => 'info-circle',
        'mail' => 'envelope-regular',
        'refresh' => 'redo',
        'remove' => 'times',
        'settings' => 'wrench',
        'settings-alt' => 'cog',
        'warning' => 'exclamation-triangle',
    ];

    $brands = [
        '500px',
        'accessible-icon',
        'accusoft',
        'acquisitions-incorporated',
        'adn',
        'adobe',
        'adversal',
        'affiliatetheme',
        'airbnb',
        'algolia',
        'alipay',
        'amazon-pay',
        'amazon',
        'amilia',
        'android',
        'angellist',
        'angrycreative',
        'angular',
        'app-store-ios',
        'app-store',
        'apper',
        'apple-pay',
        'apple',
        'artstation',
        'asymmetrik',
        'atlassian',
        'audible',
        'autoprefixer',
        'avianex',
        'aviato',
        'aws',
        'bandcamp',
        'battle-net',
        'behance-square',
        'behance',
        'bimobject',
        'bitbucket',
        'bitcoin',
        'bity',
        'black-tie',
        'blackberry',
        'blogger-b',
        'blogger',
        'bluetooth-b',
        'bluetooth',
        'bootstrap',
        'btc',
        'buffer',
        'buromobelexperte',
        'buy-n-large',
        'buysellads',
        'canadian-maple-leaf',
        'cc-amazon-pay',
        'cc-amex',
        'cc-apple-pay',
        'cc-diners-club',
        'cc-discover',
        'cc-jcb',
        'cc-mastercard',
        'cc-paypal',
        'cc-stripe',
        'cc-visa',
        'centercode',
        'centos',
        'chrome',
        'chromecast',
        'cloudscale',
        'cloudsmith',
        'cloudversify',
        'codepen',
        'codiepie',
        'confluence',
        'connectdevelop',
        'contao',
        'cotton-bureau',
        'cpanel',
        'creative-commons-by',
        'creative-commons-nc-eu',
        'creative-commons-nc-jp',
        'creative-commons-nc',
        'creative-commons-nd',
        'creative-commons-pd-alt',
        'creative-commons-pd',
        'creative-commons-remix',
        'creative-commons-sa',
        'creative-commons-sampling-plus',
        'creative-commons-sampling',
        'creative-commons-share',
        'creative-commons-zero',
        'creative-commons',
        'critical-role',
        'css3-alt',
        'css3',
        'cuttlefish',
        'd-and-d-beyond',
        'd-and-d',
        'dashcube',
        'delicious',
        'deploydog',
        'deskpro',
        'dev',
        'deviantart',
        'dhl',
        'diaspora',
        'digg',
        'digital-ocean',
        'discord',
        'discourse',
        'dochub',
        'docker',
        'draft2digital',
        'dribbble-square',
        'dribbble',
        'dropbox',
        'drupal',
        'dyalog',
        'earlybirds',
        'ebay',
        'edge',
        'elementor',
        'ello',
        'ember',
        'empire',
        'envira',
        'erlang',
        'ethereum',
        'etsy',
        'evernote',
        'expeditedssl',
        'facebook-f',
        'facebook-messenger',
        'facebook-square',
        'facebook',
        'fantasy-flight-games',
        'fedex',
        'fedora',
        'figma',
        'firefox-browser',
        'firefox',
        'first-order-alt',
        'first-order',
        'firstdraft',
        'flickr',
        'flipboard',
        'fly',
        'font-awesome-alt',
        'font-awesome-flag',
        'font-awesome-logo-full',
        'font-awesome',
        'fonticons-fi',
        'fonticons',
        'fort-awesome-alt',
        'fort-awesome',
        'forumbee',
        'foursquare',
        'free-code-camp',
        'freebsd',
        'fulcrum',
        'galactic-republic',
        'galactic-senate',
        'get-pocket',
        'gg-circle',
        'gg',
        'git-alt',
        'git-square',
        'git',
        'github-alt',
        'github-square',
        'github',
        'gitkraken',
        'gitlab',
        'gitter',
        'glide-g',
        'glide',
        'gofore',
        'goodreads-g',
        'goodreads',
        'google-drive',
        'google-play',
        'google-plus-g',
        'google-plus-square',
        'google-plus',
        'google-wallet',
        'google',
        'gratipay',
        'grav',
        'gripfire',
        'grunt',
        'gulp',
        'hacker-news-square',
        'hacker-news',
        'hackerrank',
        'hips',
        'hire-a-helper',
        'hooli',
        'hornbill',
        'hotjar',
        'houzz',
        'html5',
        'hubspot',
        'ideal',
        'imdb',
        'instagram',
        'intercom',
        'internet-explorer',
        'invision',
        'ioxhost',
        'itch-io',
        'itunes-note',
        'itunes',
        'java',
        'jedi-order',
        'jenkins',
        'jira',
        'joget',
        'joomla',
        'js-square',
        'js',
        'jsfiddle',
        'kaggle',
        'keybase',
        'keycdn',
        'kickstarter-k',
        'kickstarter',
        'korvue',
        'laravel',
        'lastfm-square',
        'lastfm',
        'leanpub',
        'less',
        'line',
        'linkedin-in',
        'linkedin',
        'linode',
        'linux',
        'lyft',
        'magento',
        'mailchimp',
        'mandalorian',
        'markdown',
        'mastodon',
        'maxcdn',
        'mdb',
        'medapps',
        'medium-m',
        'medium',
        'medrt',
        'meetup',
        'megaport',
        'mendeley',
        'microblog',
        'microsoft',
        'mix',
        'mixcloud',
        'mizuni',
        'modx',
        'monero',
        'napster',
        'neos',
        'nimblr',
        'node-js',
        'node',
        'npm',
        'ns8',
        'nutritionix',
        'odnoklassniki-square',
        'odnoklassniki',
        'old-republic',
        'opencart',
        'openid',
        'opera',
        'optin-monster',
        'orcid',
        'osi',
        'page4',
        'pagelines',
        'palfed',
        'patreon',
        'paypal',
        'penny-arcade',
        'periscope',
        'phabricator',
        'phoenix-framework',
        'phoenix-squadron',
        'php',
        'pied-piper-alt',
        'pied-piper-hat',
        'pied-piper-pp',
        'pied-piper-square',
        'pied-piper',
        'pinterest-p',
        'pinterest-square',
        'pinterest',
        'playstation',
        'product-hunt',
        'pushed',
        'python',
        'qq',
        'quinscape',
        'quora',
        'r-project',
        'raspberry-pi',
        'ravelry',
        'react',
        'reacteurope',
        'readme',
        'rebel',
        'red-river',
        'reddit-alien',
        'reddit-square',
        'reddit',
        'redhat',
        'renren',
        'replyd',
        'researchgate',
        'resolving',
        'rev',
        'rocketchat',
        'rockrms',
        'safari',
        'salesforce',
        'sass',
        'schlix',
        'scribd',
        'searchengin',
        'sellcast',
        'sellsy',
        'servicestack',
        'shirtsinbulk',
        'shopware',
        'simplybuilt',
        'sistrix',
        'sith',
        'sketch',
        'skyatlas',
        'skype',
        'slack-hash',
        'slack',
        'slideshare',
        'snapchat-ghost',
        'snapchat-square',
        'snapchat',
        'soundcloud',
        'sourcetree',
        'speakap',
        'speaker-deck',
        'spotify',
        'squarespace',
        'stack-exchange',
        'stack-overflow',
        'stackpath',
        'staylinked',
        'steam-square',
        'steam-symbol',
        'steam',
        'sticker-mule',
        'strava',
        'stripe-s',
        'stripe',
        'studiovinari',
        'stumbleupon-circle',
        'stumbleupon',
        'superpowers',
        'supple',
        'suse',
        'swift',
        'symfony',
        'teamspeak',
        'telegram-plane',
        'telegram',
        'tencent-weibo',
        'the-red-yeti',
        'themeco',
        'themeisle',
        'think-peaks',
        'trade-federation',
        'trello',
        'tripadvisor',
        'tumblr-square',
        'tumblr',
        'twitch',
        'twitter-square',
        'twitter',
        'typo3',
        'uber',
        'ubuntu',
        'uikit',
        'umbraco',
        'uniregistry',
        'unity',
        'untappd',
        'ups',
        'usb',
        'usps',
        'ussunnah',
        'vaadin',
        'viacoin',
        'viadeo-square',
        'viadeo',
        'viber',
        'vimeo-square',
        'vimeo-v',
        'vimeo',
        'vine',
        'vk',
        'vnv',
        'vuejs',
        'waze',
        'weebly',
        'weibo',
        'weixin',
        'whatsapp-square',
        'whatsapp',
        'whmcs',
        'wikipedia-w',
        'windows',
        'wix',
        'wizards-of-the-coast',
        'wolf-pack-battalion',
        'wordpress-simple',
        'wordpress',
        'wpbeginner',
        'wpexplorer',
        'wpforms',
        'wpressr',
        'xbox',
        'xing-square',
        'xing',
        'y-combinator',
        'yahoo',
        'yammer',
        'yandex-international',
        'yandex',
        'yarn',
        'yelp',
        'yoast',
        'youtube-square',
        'youtube',
        'zhihu',
    ];
    
    foreach ($classes as $icon_class) {
        if (!preg_match_all('/^elgg-icon-(.+)/i', $icon_class)) {
            continue;
        }
        
        // strip elgg-icon-
        $base_icon = preg_replace('/^elgg-icon-(.+)/i', '$1', $icon_class);
        
        // convert common icons
        $base_icon = elgg_extract($base_icon, $common_icons, $base_icon);
        
        // map solid/regular/light iconnames to correct classes
        if (preg_match('/.*-solid$/', $base_icon)) {
            $base_icon = preg_replace('/(.*)-solid$/', '$1', $base_icon);
            $classes[] = 'fas';
        } elseif (preg_match('/.*-regular$/', $base_icon)) {
            $base_icon = preg_replace('/(.*)-regular$/', '$1', $base_icon);
            $classes[] = 'far';
        } elseif (preg_match('/.*-light$/', $base_icon)) {
            // currently light is only available in FontAwesome 5 Pro
            $base_icon = preg_replace('/(.*)-light$/', '$1', $base_icon);
            $classes[] = 'fal';
        } elseif (in_array($base_icon, $brands)) {
            $classes[] = 'fab';
        } else {
            $classes[] = 'fas';
        }

        $classes[] = "fa-{$base_icon}";
    }

    $classes = array_unique($classes);

    return elgg_trigger_plugin_hook('classes', 'icon', null, $classes);
}

function elgg_view_url(string $href, string $text = null, array $options = []): string {
    $options['is_trusted'] = elgg_extract('is_trusted', $options, true);
    $options['href'] = $href;
    $options['text'] = $text;
    
    return elgg_view('output/url', $options);
}

function elgg_view_entity_url(\ElggEntity $entity, array $options = []): string {
    return elgg_view_url($entity->getURL(), $entity->getDisplayName(), $options);
}