mirror of
https://github.com/element-hq/element-web.git
synced 2024-12-15 08:51:29 +03:00
121 lines
3.9 KiB
JavaScript
121 lines
3.9 KiB
JavaScript
/*
|
|
Copyright 2016 OpenMarket Ltd
|
|
Copyright 2019 The Matrix.org Foundation C.I.C.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
import { _t } from '../languageHandler';
|
|
|
|
/**
|
|
* formats numbers to fit into ~3 characters, suitable for badge counts
|
|
* e.g: 999, 9.9K, 99K, 0.9M, 9.9M, 99M, 0.9B, 9.9B
|
|
*/
|
|
export function formatCount(count) {
|
|
if (count < 1000) return count;
|
|
if (count < 10000) return (count / 1000).toFixed(1) + "K";
|
|
if (count < 100000) return (count / 1000).toFixed(0) + "K";
|
|
if (count < 10000000) return (count / 1000000).toFixed(1) + "M";
|
|
if (count < 100000000) return (count / 1000000).toFixed(0) + "M";
|
|
return (count / 1000000000).toFixed(1) + "B"; // 10B is enough for anyone, right? :S
|
|
}
|
|
|
|
/**
|
|
* Format a count showing the whole number but making it a bit more readable.
|
|
* e.g: 1000 => 1,000
|
|
*/
|
|
export function formatCountLong(count) {
|
|
const formatter = new Intl.NumberFormat();
|
|
return formatter.format(count)
|
|
}
|
|
|
|
/**
|
|
* format a size in bytes into a human readable form
|
|
* e.g: 1024 -> 1.00 KB
|
|
*/
|
|
export function formatBytes(bytes, decimals = 2) {
|
|
if (bytes === 0) return '0 Bytes';
|
|
|
|
const k = 1024;
|
|
const dm = decimals < 0 ? 0 : decimals;
|
|
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
|
|
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
|
|
}
|
|
|
|
/**
|
|
* format a key into groups of 4 characters, for easier visual inspection
|
|
*
|
|
* @param {string} key key to format
|
|
*
|
|
* @return {string}
|
|
*/
|
|
export function formatCryptoKey(key) {
|
|
return key.match(/.{1,4}/g).join(" ");
|
|
}
|
|
/**
|
|
* calculates a numeric hash for a given string
|
|
*
|
|
* @param {string} str string to hash
|
|
*
|
|
* @return {number}
|
|
*/
|
|
export function hashCode(str) {
|
|
let hash = 0;
|
|
let i;
|
|
let chr;
|
|
if (str.length === 0) {
|
|
return hash;
|
|
}
|
|
for (i = 0; i < str.length; i++) {
|
|
chr = str.charCodeAt(i);
|
|
hash = ((hash << 5) - hash) + chr;
|
|
hash |= 0;
|
|
}
|
|
return Math.abs(hash);
|
|
}
|
|
|
|
export function getUserNameColorClass(userId) {
|
|
const colorNumber = (hashCode(userId) % 8) + 1;
|
|
return `mx_Username_color${colorNumber}`;
|
|
}
|
|
|
|
/**
|
|
* Constructs a written English string representing `items`, with an optional
|
|
* limit on the number of items included in the result. If specified and if the
|
|
* length of `items` is greater than the limit, the string "and n others" will
|
|
* be appended onto the result. If `items` is empty, returns the empty string.
|
|
* If there is only one item, return it.
|
|
* @param {string[]} items the items to construct a string from.
|
|
* @param {number?} itemLimit the number by which to limit the list.
|
|
* @returns {string} a string constructed by joining `items` with a comma
|
|
* between each item, but with the last item appended as " and [lastItem]".
|
|
*/
|
|
export function formatCommaSeparatedList(items, itemLimit) {
|
|
const remaining = itemLimit === undefined ? 0 : Math.max(
|
|
items.length - itemLimit, 0,
|
|
);
|
|
if (items.length === 0) {
|
|
return "";
|
|
} else if (items.length === 1) {
|
|
return items[0];
|
|
} else if (remaining > 0) {
|
|
items = items.slice(0, itemLimit);
|
|
return _t("%(items)s and %(count)s others", { items: items.join(', '), count: remaining } );
|
|
} else {
|
|
const lastItem = items.pop();
|
|
return _t("%(items)s and %(lastItem)s", { items: items.join(', '), lastItem: lastItem });
|
|
}
|
|
}
|