Source: node_modules/common-sk/modules/human.js

// Copyright 2019 Google LLC
//
// 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
//
//     https://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.
const TIME_DELTAS = [
    { units: 'w', delta: 7 * 24 * 60 * 60 },
    { units: 'd', delta: 24 * 60 * 60 },
    { units: 'h', delta: 60 * 60 },
    { units: 'm', delta: 60 },
    { units: 's', delta: 1 },
];
/** @constant {number} */
export const KB = 1024;
/** @constant {number} */
export const MB = KB * 1024;
/** @constant {number} */
export const GB = MB * 1024;
/** @constant {number} */
export const TB = GB * 1024;
/** @constant {number} */
export const PB = TB * 1024;
const BYTES_DELTAS = [
    { units: ' PB', delta: PB },
    { units: ' TB', delta: TB },
    { units: ' GB', delta: GB },
    { units: ' MB', delta: MB },
    { units: ' KB', delta: KB },
    { units: ' B', delta: 1 },
];
/** Left pad a number with 0s.
 *
 * @param num - The number to pad.
 * @param size - The number of digits to pad out to.
 */
export function pad(num, size) {
    let str = num + '';
    while (str.length < size) {
        str = '0' + str;
    }
    return str;
}
/**
 * Returns a human-readable format of the given duration in seconds.
 * For example, 'strDuration(123)' would return "2m 3s".
 * Negative seconds is treated the same as positive seconds.
 *
 * @param seconds - The duration.
 */
export function strDuration(seconds) {
    if (seconds < 0) {
        seconds = -seconds;
    }
    if (seconds === 0) {
        return '  0s';
    }
    let rv = '';
    for (const td of TIME_DELTAS) {
        if (td.delta <= seconds) {
            let s = Math.floor(seconds / td.delta) + td.units;
            while (s.length < 4) {
                s = ' ' + s;
            }
            rv += s;
            seconds = seconds % td.delta;
        }
    }
    return rv;
}
/**
 * Returns the difference between the current time and 's' as a string in a
 * human friendly format. If 's' is a number it is assumed to contain the time
 * in milliseconds otherwise it is assumed to contain a time string parsable
 * by Date.parse().
 *
 * For example, a difference of 123 seconds between 's' and the current time
 * would return "2m".
 *
 * @param milliseconds - The time in milliseconds or a time string.
 * @param now - The time to diff against, if not supplied then the diff
 * is done against Date.now().
 */
export function diffDate(s, now) {
    if (now === undefined) {
        now = Date.now();
    }
    const ms = typeof s === 'number' ? s : Date.parse(s);
    let diff = (ms - now) / 1000;
    if (diff < 0) {
        diff = -1.0 * diff;
    }
    return humanize(diff, TIME_DELTAS);
}
/**
 * Formats the amount of bytes in a human friendly format.
 * unit may be supplied to indicate b is not in bytes, but in something
 * like kilobytes (KB) or megabytes (MB)
 *
 * @example
 * // returns "1 KB"
 * bytes(1234)
 * @example
 * // returns "5 GB"
 * bytes(5321, MB)
 *
 * @param b - The number of bytes in units 'unit'.
 * @param unit - The number of bytes per unit.
 */
export function bytes(b, unit = 1) {
    return humanize(b * unit, BYTES_DELTAS);
}
/** localeTime formats the provided Date object in locale time and appends the timezone to the end.
 *
 * @param date The date to format.
 */
export function localeTime(date) {
    // caching timezone could be buggy, especially if times from a wide range
    // of dates are used. The main concern would be crossing over Daylight
    // Savings time and having some times be erroneously in EST instead of
    // EDT, for example
    const str = date.toString();
    const timezone = str.substring(str.indexOf('('));
    return date.toLocaleString() + ' ' + timezone;
}
function humanize(n, deltas) {
    for (let i = 0; i < deltas.length - 1; i++) {
        // If n would round to '60s', return '1m' instead.
        const nextDeltaRounded = Math.round(n / deltas[i + 1].delta) * deltas[i + 1].delta;
        if (nextDeltaRounded / deltas[i].delta >= 1) {
            return Math.round(n / deltas[i].delta) + deltas[i].units;
        }
    }
    const index = deltas.length - 1;
    return Math.round(n / deltas[index].delta) + deltas[index].units;
}
//# sourceMappingURL=human.js.map