pfp.lgbt-wrapper/lib/index.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const FormData = require("form-data");
const node_fetch_1 = __importDefault(require("node-fetch"));
class PfP {
    constructor() {
        this.baseUrl = 'https://api.pfp.lgbt/v3/';
        this.rateLimit = false;
        this.rateLimitEnd = 0;
    }
    _fetch(url, init, type = 'json') {
        return new Promise((resolve, reject) => {
            if (this.rateLimit)
                reject('Rate limit reached!');
            node_fetch_1.default(url, init).then((res) => __awaiter(this, void 0, void 0, function* () {
                const rateLimitRemaining = res.headers.get('x-ratelimit-remaining');
                let rateLimitReset = res.headers.get('x-ratelimit-reset');
                if (rateLimitRemaining === '0') {
                    this.rateLimit = true;
                    const currentTimeStamp = Date.now();
                    rateLimitReset = rateLimitReset ? parseInt(rateLimitReset) * 1000 : currentTimeStamp + 5000;
                    this.rateLimitEnd = rateLimitReset;
                    if (this.resetTimeout)
                        clearTimeout(this.resetTimeout);
                    this.resetTimeout = setTimeout(() => (this.rateLimit = false), rateLimitReset - currentTimeStamp);
                }
                if (res.status > 299 || res.status < 200)
                    reject(`${res.status}: ${res.statusText}`);
                try {
                    if (type === 'img')
                        yield res.buffer().then(resolve);
                    else if (type === 'json')
                        yield res.json().then(resolve);
                    else
                        reject(`${type} is not a valid mime type`);
                }
                catch (error) {
                    reject(error);
                }
            }));
        });
    }
    _fetchImage(url, buf, alpha) {
        const data = new FormData();
        data.append('file', buf, 'image.png');
        if (alpha)
            data.append('alpha', alpha);
        return this._fetch(url, {
            method: 'POST',
            body: data,
            headers: Object.assign({}, data.getHeaders())
        }, 'img');
    }
    _urlToBuf(url) {
        return node_fetch_1.default(url)
            .then(res => res.buffer())
            .catch(() => null);
    }
    /**
     * Get an object containing all valid flags and their defaults
     * @returns `Promise<FlagResponse>`
     */
    getFlags() {
        return this._fetch(this.baseUrl + 'flags', {}, 'json');
    }
    /**
     * Get an image of the provided flag
     * @param flag The target flag. You can get a list of all flags with the `getFlags()` method
     * @returns `Promise<Buffer>`
     */
    getFlag(flag = 'pride') {
        return this._fetch(this.baseUrl + 'icon/' + flag, {}, 'img');
    }
    /**
     * Create a static lgbtifed image
     * @param image Buffer/Url of the image to lgbtify
     * @param flag The Pride flag to add
     * @param type The effect type
     * @param style The effect style
     * @param format The format of the resulting image
     * @param alpha The alpha the effect will have
     * @returns `Promise<Buffer>`
     */
    createStatic(image, flag, type = 'circle', style = 'solid', format = 'png', alpha) {
        return __awaiter(this, void 0, void 0, function* () {
            const url = `${this.baseUrl}image/static/${type}/${style}/${flag}.${format}`;
            if (!(image instanceof Buffer))
                image = (yield this._urlToBuf(image));
            if (!image)
                throw new Error('Invalid image provided');
            return this._fetchImage(url, image, alpha);
        });
    }
    /**
     * Create an animated lgbtifed image
     * @param image Buffer/Url of the image to lgbtify
     * @param flag The Pride flag to add
     * @param type The effect type
     * @param alpha The alpha the effect will have
     * @returns `Promise<Buffer>`
     */
    createAnimated(image, flag, type = 'circle', alpha) {
        return __awaiter(this, void 0, void 0, function* () {
            const url = `${this.baseUrl}image/animated/${type}/${flag}`;
            if (!(image instanceof Buffer))
                image = (yield this._urlToBuf(image));
            if (!image)
                throw new Error('Invalid image provided');
            return this._fetchImage(url, image, alpha);
        });
    }
}
exports.default = PfP;