Source: api.js

  1. const fetch = require('node-fetch');
  2. const EventEmitter = require('events');
  3. const base = 'https://api.cool-img-api.ml/';
  4. const { getContent } = require('./function');
  5.                     
  6. class API extends EventEmitter {
  7.                     
  8.     /**
  9.      * @param {string} text Text to apprear
  10.      * @returns {Buffer} The Processed image Buffer
  11.      */
  12.     async achievement(text) {
  13.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  14.         const url = base + `achievement?text=${encodeURIComponent(text)}`;
  15.         return await getContent(url);
  16.     }
  18.     /**
  19.      * @param {string} text Text to apprear
  20.      * @param {string} earth Text to apprear
  21.      * @param {string} image The Image URL
  22.      * @returns {Buffer} The Processed image Buffer
  23.      */
  24.     async alwayshasbeen(text, earth, image) {
  25.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  26.         if (!earth) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  27.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  28.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  29.         const url = base + `alwayshasbeen?text=${encodeURIComponent(text)}&earth=${encodeURIComponent(earth)}&image=${encodeURIComponent(image)}`;
  30.         return await getContent(url);
  31.     }
  33.     /**
  34.      * @param {string} image The Image URL
  35.      * @returns {Buffer} The Processed image Buffer
  36.      */
  37.     async amiajoke(image) {
  38.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  39.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  40.         const url = base + `amiajoke?image=${encodeURIComponent(image)}`;
  41.         return await getContent(url);
  42.     }
  44.     /**
  45.      * @param {string} image The Image URL
  46.      * @returns {Buffer} The Processed image Buffer
  47.      */
  48.     async bad(image) {
  49.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  50.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  51.         const url = base + `bad?image=${encodeURIComponent(image)}`;
  52.         return await getContent(url);
  53.     }
  55.     /**
  56.      * @param {string} image The Image URL
  57.      * @returns {Buffer} The Processed image Buffer
  58.      */
  59.     async beautiful(image) {
  60.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  61.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  62.         const url = base + `beautiful?image=${encodeURIComponent(image)}`;
  63.         return await getContent(url);
  64.     }
  66.     /**
  67.      * @param {string} image The Image URL
  68.      * @param {string} image2 The Image URL
  69.      * @returns {Buffer} The Processed image Buffer
  70.      */
  71.     async bed(image, image2) {
  72.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  73.         if (!image2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  74.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  75.         const url = base + `bed?image=${encodeURIComponent(image)}&image2=${encodeURIComponent(image2)}`;
  76.         return await getContent(url);
  77.     }
  79.     /**
  80.      * @returns {Buffer} The Processed image Buffer
  81.      */
  82.     async birb() {
  83.         const url = base + 'birb';
  84.         return await getContent(url);
  85.     }
  87.     /**
  88.      * @param {string} image The Image URL
  89.      * @returns {Buffer} The Processed image Buffer
  90.      */
  91.     async blur(image) {
  92.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  93.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  94.         const url = base + `blur?image=${encodeURIComponent(image)}`;
  95.         return await getContent(url);
  96.     }
  98.     /**
  99.      * @param {string} text Text to apprear
  100.      * @returns {Buffer} The Processed image Buffer
  101.      */
  102.     async calling(text) {
  103.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  104.         const url = base + `calling?text=${encodeURIComponent(text)}`;
  105.         return await getContent(url);
  106.     }
  108.     /**
  109.      * @param {string} text Text to apprear
  110.      * @returns {Buffer} The Processed image Buffer
  111.      */
  112.     async captcha(text) {
  113.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  114.         const url = base + `captcha?text=${encodeURIComponent(text)}`;
  115.         return await getContent(url);
  116.     }
  118.     /**
  119.      * @returns {Buffer} The Processed image Buffer
  120.      */
  121.     async cats() {
  122.         const url = base + 'cats';
  123.         return await getContent(url);
  124.     }
  126.     /**
  127.      * @param {string} text Text to apprear
  128.      * @returns {Buffer} The Processed image Buffer
  129.      */
  130.     async challenge(text) {
  131.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  132.         const url = base + `challenge?text=${encodeURIComponent(text)}`;
  133.         return await getContent(url);
  134.     }
  136.     /**
  137.      * @param {string} text Text to apprear
  138.      * @returns {Buffer} The Processed image Buffer
  139.      */
  140.     async changemymind(text) {
  141.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  142.         const url = base + `changemymind?text=${encodeURIComponent(text)}`;
  143.         return await getContent(url);
  144.     }
  146.     /**
  147.      * @param {string} text Text to apprear
  148.      * @returns {Buffer} The Processed image Buffer
  149.      */
  150.     async clyde(text) {
  151.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  152.         const url = base + `clyde?text=${encodeURIComponent(text)}`;
  153.         return await getContent(url);
  154.     }
  156.     /**
  157.      * @param {string} image The Image URL
  158.      * @returns {Buffer} The Processed image Buffer
  159.      */
  160.     async communist(image) {
  161.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  162.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  163.         const url = base + `communist?image=${encodeURIComponent(image)}`;
  164.         return await getContent(url);
  165.     }
  167.     /**
  168.      * @param {string} text Text to apprear
  169.      * @param {string} text2 Text to apprear
  170.      * @returns {Buffer} The Processed image Buffer
  171.      */
  172.     async didyoumean(text, text2) {
  173.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  174.         if (!text2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  175.         const url = base + `didyoumean?top=${encodeURIComponent(text)}&bottom=${encodeURIComponent(text2)}`;
  176.         return await getContent(url);
  177.     }
  179.     /**
  180.      * @param {string} text Text to apprear
  181.      * @param {string} color Color of the username
  182.      * @param {string} username Username to appear
  183.      * @param {string} image The Image URL
  184.      * @returns {Buffer} The Processed image Buffer
  185.      */
  186.     async discord_message(text, color, username, image) {
  187.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  188.         if (!color) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  189.         if (!username) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  190.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  191.         const url = base + `discord-message?message=${encodeURIComponent(text)}&color=${encodeURIComponent(color)}&username=${encodeURIComponent(username)}&avatar=${encodeURIComponent(image)}`;
  192.         console.log(url);
  193.         return await getContent(url);
  194.     }
  196.     /**
  197.      * @param {string} text Text to apprear
  198.      * @param {string} text2 Text to apprear
  199.      * @returns {Buffer} The Processed image Buffer
  200.      */
  201.     async dissapointed(text, text2) {
  202.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  203.         if (!text2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  204.         const url = base + `dissapointed?top=${encodeURIComponent(text)}&bottom=${encodeURIComponent(text2)}`;
  205.         return await getContent(url);
  206.     }
  208.     /**
  209.      * @returns {Buffer} The Processed image Buffer
  210.      */
  211.     async dogs() {
  212.         const url = base + 'dogs';
  213.         return await getContent(url);
  214.     }
  216.     /**
  217.      * @param {string} text Text to apprear
  218.      * @param {string} text2 Text to apprear
  219.      * @returns {Buffer} The Processed image Buffer
  220.      */
  221.     async drake(text, text2) {
  222.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  223.         if (!text2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  224.         const url = base + `drake?top=${encodeURIComponent(text)}&bottom=${encodeURIComponent(text2)}`;
  225.         return await getContent(url);
  226.     }
  228.     /**
  229.      * @param {string} image The Image URL
  230.      * @returns {Buffer} The Processed image Buffer
  231.      */
  232.     async facepalm(image) {
  233.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  234.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  235.         const url = base + `facepalm?image=${encodeURIComponent(image)}`;
  236.         return await getContent(url);
  237.     }
  239.     /**
  240.      * @param {string} text Text to apprear
  241.      * @returns {Buffer} The Processed image Buffer
  242.      */
  243.     async facts(text) {
  244.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  245.         const url = base + `facts?text=${encodeURIComponent(text)}`;
  246.         return await getContent(url);
  247.     }
  249.     /**
  250.      * @param {string} image The Image URL
  251.      * @returns {Buffer} The Processed image Buffer
  252.      */
  253.     async gay(image) {
  254.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  255.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  256.         const url = base + `gay?image=${encodeURIComponent(image)}`;
  257.         return await getContent(url);
  258.     }
  260.     /**
  261.      * @param {string} image The Image URL
  262.      * @returns {Buffer} The Processed image Buffer
  263.      */
  264.     async gun(image) {
  265.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  266.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  267.         const url = base + `gun?image=${encodeURIComponent(image)}`;
  268.         return await getContent(url);
  269.     }
  271.     /**
  272.      * @param {string} image The Image URL
  273.      * @returns {Buffer} The Processed image Buffer
  274.      */
  275.     async hitler(image) {
  276.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  277.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  278.         const url = base + `hitler?image=${encodeURIComponent(image)}`;
  279.         return await getContent(url);
  280.     }
  282.     /**
  283.      * @param {string} image The Image URL
  284.      * @returns {Buffer} The Processed image Buffer
  285.      */
  286.     async invert(image) {
  287.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  288.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  289.         const url = base + `invert?image=${encodeURIComponent(image)}`;
  290.         return await getContent(url);
  291.     }
  293.     /**
  294.      * @param {string} image The Image URL
  295.      * @returns {Buffer} The Processed image Buffer
  296.      */
  297.     async jail(image) {
  298.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  299.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  300.         const url = base + `jail?image=${encodeURIComponent(image)}`;
  301.         return await getContent(url);
  302.     }
  304.     /**
  305.      * @param {string} image The Image URL
  306.      * @returns {Buffer} The Processed image Buffer
  307.      */
  308.     async jokeoverhead(image) {
  309.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  310.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  311.         const url = base + `jokeoverhead?image=${encodeURIComponent(image)}`;
  312.         return await getContent(url);
  313.     }
  315.     /**
  316.      * @returns {Buffer} The Processed image Buffer
  317.      */
  318.     async meme() {
  319.         const url = base + 'meme';
  320.         return await getContent(url);
  321.     }
  323.     /**
  324.      * @param {string} text Text to apprear
  325.      * @param {string} author Author to apprear
  326.      * @param {string} image The Image URL
  327.      * @returns {Buffer} The Processed image Buffer
  328.      */
  329.     async play_store(text, author, image) {
  330.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  331.         if (!author) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  332.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  333.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  334.         const url = base + `play-store?image=${encodeURIComponent(image)}&text=${encodeURIComponent(text)}&author=${encodeURIComponent(author)}`;
  335.         return await getContent(url);
  336.     }
  338.     /**
  339.      * @param {string} text Text to apprear
  340.      * @returns {Buffer} The Processed image Buffer
  341.      */
  342.     async presentation(text) {
  343.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  344.         const url = base + `presentation?text=${encodeURIComponent(text)}`;
  345.         return await getContent(url);
  346.     }
  348.     /**
  349.      * @returns {Object} The Processed image Buffer
  350.      */
  351.     async random_captcha() {
  352.         const url = await fetch(base + 'random-captcha');
  353.         const data = await url.json();
  354.         return data;
  355.     }
  357.     /**
  358.      * @param {string} image The Image URL
  359.      * @returns {Buffer} The Processed image Buffer
  360.      */
  361.     async rip(image) {
  362.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  363.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  364.         const url = base + `rip?image=${encodeURIComponent(image)}`;
  365.         return await getContent(url);
  366.     }
  368.     /**
  369.      * @param {string} image The Image URL
  370.      * @returns {Buffer} The Processed image Buffer
  371.      */
  372.     async salty(image) {
  373.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  374.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  375.         const url = base + `salty?image=${encodeURIComponent(image)}`;
  376.         return await getContent(url);
  377.     }
  379.     /**
  380.      * @param {string} text Text to apprear
  381.      * @returns {Buffer} The Processed image Buffer
  382.      */
  383.     async scroll(text) {
  384.         if (!text) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  385.         const url = base + `scroll?text=${encodeURIComponent(text)}`;
  386.         return await getContent(url);
  387.     }
  389.     /**
  390.      * @param {string} image The Image URL
  391.      * @returns {Buffer} The Processed image Buffer
  392.      */
  393.     async shame(image) {
  394.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  395.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  396.         const url = base + `shame?image=${encodeURIComponent(image)}`;
  397.         return await getContent(url);
  398.     }
  400.     /**
  401.      * @param {string} image The Image URL
  402.      * @param {string} image2 The Image URL
  403.      * @returns {Buffer} The Processed image Buffer
  404.      */
  405.     async ship(image, image2) {
  406.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  407.         if (!image2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  408.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  409.         const url = base + `ship?user=${encodeURIComponent(image)}&user2=${encodeURIComponent(image2)}`;
  410.         return await getContent(url);
  411.     }
  413.     /**
  414.      * @param {string} image The Image URL
  415.      * @returns {Buffer} The Processed image Buffer
  416.      */
  417.     async shit(image) {
  418.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  419.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  420.         const url = base + `shit?image=${encodeURIComponent(image)}`;
  421.         return await getContent(url);
  422.     }
  424.     /**
  425.      * @param {string} image The Image URL
  426.      * @returns {Buffer} The Processed image Buffer
  427.      */
  428.     async simp(image) {
  429.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  430.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  431.         const url = base + `simp?image=${encodeURIComponent(image)}`;
  432.         return await getContent(url);
  433.     }
  435.     /**
  436.      * @param {string} image The Image URL
  437.      * @param {string} image2 The Image URL
  438.      * @returns {Buffer} The Processed image Buffer
  439.      */
  440.     async spank(image, image2) {
  441.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  442.         if (!image2) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  443.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  444.         const url = base + `spank?user=${encodeURIComponent(image)}&user2=${encodeURIComponent(image2)}`;
  445.         return await getContent(url);
  446.     }
  448.     /**
  449.      * @param {string} image The Image URL
  450.      * @returns {Buffer} The Processed image Buffer
  451.      */
  452.     async trash(image) {
  453.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  454.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  455.         const url = base + `trash?image=${encodeURIComponent(image)}`;
  456.         return await getContent(url);
  457.     }
  459.     /**
  460.      * @param {string} image The Image URL
  461.      * @returns {Buffer} The Processed image Buffer
  462.      */
  463.     async triggered(image) {
  464.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  465.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  466.         const url = base + `triggered?image=${encodeURIComponent(image)}`;
  467.         return await getContent(url);
  468.     }
  470.     /**
  471.      * @param {string} image The Image URL
  472.      * @returns {Buffer} The Processed image Buffer
  473.      */
  474.     async wanted(image) {
  475.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  476.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  477.         const url = base + `wanted?image=${encodeURIComponent(image)}`;
  478.         return await getContent(url);
  479.     }
  481.     /**
  482.      * @param {string} image The Image URL
  483.      * @returns {Buffer} The Processed image Buffer
  484.      */
  485.     async wasted(image) {
  486.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  487.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  488.         const url = base + `wasted?image=${encodeURIComponent(image)}`;
  489.         return await getContent(url);
  490.     }
  492.     /**
  493.      * @param {string} location Text to apprear
  494.      * @param {string} image The Image URL
  495.      * @returns {Buffer} The Processed image Buffer
  496.      */
  497.     async weather_card(location, image) {
  498.         if (!location) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  499.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  500.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  501.         const url = base + `weather-card?location=${encodeURIComponent(location)}&background=${encodeURIComponent(image)}`;
  502.         return await getContent(url);
  503.     }
  505.     /**
  506.      * @param {string} image The Image URL
  507.      * @returns {Buffer} The Processed image Buffer
  508.      */
  509.     async what(image) {
  510.         if (!image) throw new Error('APIError: Inavlid parameters provided! Docs: https://cool-img-api.js.org');
  511.         if (typeof image !== 'string') throw new Error('image URL should be passed as a STRING');
  512.         const url = base + `what?image=${encodeURIComponent(image)}`;
  513.         return await getContent(url);
  514.     }
  515. }
  516. module.exports = API;