jitsi_app_c0/react/features/recent-list/functions.js

// @flow

import moment from 'moment';

// MomentJS uses static language bundle loading, so in order to support dynamic
// language selection in the app we need to load all bundles that we support in
// the app.
// FIXME: If we decide to support MomentJS in other features as well we may need
// to move this import and the lenient matcher to the i18n feature.
require('moment/locale/bg');
require('moment/locale/de');
require('moment/locale/eo');
require('moment/locale/es');
require('moment/locale/fr');
require('moment/locale/hy-am');
require('moment/locale/it');
require('moment/locale/nb');

// OC is not available. Please submit OC translation to the MomentJS project.

require('moment/locale/pl');
require('moment/locale/pt');
require('moment/locale/pt-br');
require('moment/locale/ru');
require('moment/locale/sk');
require('moment/locale/sl');
require('moment/locale/sv');
require('moment/locale/tr');
require('moment/locale/zh-cn');

import { i18next } from '../base/i18n';
import { parseURIString } from '../base/util';

const logger = require('jitsi-meet-logger').getLogger(__filename);

/**
 * The name of the {@code window.localStorage} item where recent rooms are
 * stored.
 *
 * @type {string}
 */
const RECENT_URL_STORAGE = 'recentURLs';

/**
 * Retrieves the recent room list that was stored using the legacy way.
 *
 * @returns {Array<Object>}
 */
export function getLegacyRecentRoomList(): Array<Object> {
    const legacyListString = window.localStorage.getItem(RECENT_URL_STORAGE);

    try {
        const legacyList = JSON.parse(legacyListString);

        if (legacyList && legacyList.length) {
            return legacyList;
        }
    } catch (error) {
        logger.warn('Unable to parse legacy recent list');
    }

    return [];
}

/**
 * Retrieves the recent room list and generates all the data needed to be
 * displayed.
 *
 * @param {Array<Object>} list - The stored recent list retrieved from Redux.
 * @returns {Array}
 */
export function getRecentRooms(list: Array<Object>): Array<Object> {
    const recentRoomDS = [];

    if (list.length) {
        // We init the locale on every list render, so then it changes
        // immediately if a language change happens in the app.
        const locale = _getSupportedLocale();

        for (const e of list) {
            const location = parseURIString(e.conference);

            if (location && location.room && location.hostname) {
                recentRoomDS.push({
                    baseURL: `${location.protocol}//${location.host}`,
                    conference: e.conference,
                    conferenceDuration: e.conferenceDuration,
                    conferenceDurationString:
                        _getDurationString(
                            e.conferenceDuration,
                            locale),
                    dateString: _getDateString(e.date, locale),
                    dateTimeStamp: e.date,
                    initials: _getInitials(location.room),
                    room: location.room,
                    serverName: location.hostname
                });
            }
        }
    }

    return recentRoomDS.reverse();
}

/**
 * Returns a well formatted date string to be displayed in the list.
 *
 * @param {number} dateTimeStamp - The UTC timestamp to be converted to String.
 * @param {string} locale - The locale to init the formatter with. Note: This
 * locale must be supported by the formatter so ensure this prerequisite before
 * invoking the function.
 * @private
 * @returns {string}
 */
function _getDateString(dateTimeStamp: number, locale: string) {
    const date = new Date(dateTimeStamp);
    const m = _getLocalizedFormatter(date, locale);

    if (date.toDateString() === new Date().toDateString()) {
        // The date is today, we use fromNow format.
        return m.fromNow();
    }

    return m.format('lll');
}

/**
 * Returns a well formatted duration string to be displayed as the conference
 * length.
 *
 * @param {number} duration - The duration in MS.
 * @param {string} locale - The locale to init the formatter with. Note: This
 * locale must be supported by the formatter so ensure this prerequisite before
 * invoking the function.
 * @private
 * @returns {string}
 */
function _getDurationString(duration: number, locale: string) {
    return _getLocalizedFormatter(duration, locale).humanize();
}

/**
 * Returns the initials supposed to be used based on the room name.
 *
 * @param {string} room - The room name.
 * @private
 * @returns {string}
 */
function _getInitials(room: string) {
    return room && room.charAt(0) ? room.charAt(0).toUpperCase() : '?';
}

/**
 * Returns a localized date formatter initialized with a specific {@code Date}
 * or duration ({@code number}).
 *
 * @private
 * @param {Date | number} dateOrDuration - The date or duration to format.
 * @param {string} locale - The locale to init the formatter with. Note: The
 * specified locale must be supported by the formatter so ensure the
 * prerequisite is met before invoking the function.
 * @returns {Object}
 */
function _getLocalizedFormatter(dateOrDuration: Date | number, locale: string) {
    const m
        = typeof dateOrDuration === 'number'
            ? moment.duration(dateOrDuration)
            : moment(dateOrDuration);

    return m.locale(locale);
}

/**
 * A lenient locale matcher to match language and dialect if possible.
 *
 * @private
 * @returns {string}
 */
function _getSupportedLocale() {
    const i18nLocale = i18next.language;
    let supportedLocale;

    if (i18nLocale) {
        const localeRegexp = new RegExp('^([a-z]{2,2})(-)*([a-z]{2,2})*$');
        const localeResult = localeRegexp.exec(i18nLocale.toLowerCase());

        if (localeResult) {
            const currentLocaleRegexp
                = new RegExp(
                    `^${localeResult[1]}(-)*${`(${localeResult[3]})*` || ''}`);

            supportedLocale
                = moment.locales().find(lang => currentLocaleRegexp.exec(lang));
        }
    }

    return supportedLocale || 'en';
}