stack-analyze 1.1.6 → 1.1.9

package/{index.js → index.cjs}

@@ -1,6 +1,5 @@
 // modules
 const axios = require("axios").default;
-const CoinGecko = require("coingecko-api");
 const {
   cpu,
   mem,
@@ -10,13 +9,9 @@ const {
   bios
 } = require("systeminformation");
 const Wappalyzer = require("wappalyzer");
+const { load } = require("cheerio");
 
-// init coingecko api
-const CoinGeckoClient = new CoinGecko();
-
-// functions
-
-const animeSearch = async (query) => {
+const animeSearch = async ({ query, results }) => {
   /* error manager */
   try {
     // call api
@@ -27,12 +22,12 @@ const animeSearch = async (query) => {
       }
     });
 
-    return data.results;
+    results(data.results);
 
-  } catch (err) { return err; }
+  } catch (err) { results(err); }
 };
 
-const bitlyInfo = async (link, token) => {
+const bitlyInfo = async ({ link, token, results }) => {
   try {
     const { data } = await axios.post(
       "https://api-ssl.bitly.com/v4/expand",
@@ -47,37 +42,42 @@ const bitlyInfo = async (link, token) => {
       }
     );
 
-    return data;
-  } catch (err) { return err; }
+    results(data);
+  } catch (err) { results(err); }
 };
 
-/*
+/**
  *
  * @descripiton call the crypto market list
+ * @param {function(any): void} callback
  * @returns { Promise<void> } - return results search
- *
  */
-const cryptoMarket = async () => {
+const cryptoMarket = async (callback) => {
   try {
     // start crypto
-    const coinData = await CoinGeckoClient.coins.markets({
-      per_page: 10
-    });
+    const { data } = await axios.get(
+      "https://api.coingecko.com/api/v3/coins/markets", {
+      params: {
+        vs_currency: "usd",
+        per_page: 10
+      }
+    }
+    );
 
     // map coinData
-    return coinData.data;
-  } catch (err) { return err; }
+    callback(data);
+  } catch (err) { callback(err); }
 };
 
-async function githubInfo(user) {
+async function githubInfo({ user, results }) {
   try {
     const { data } = await axios.get(`https://api.github.com/users/${user}`);
 
-    return data;
-  } catch (err) { return err; }
+    results(data);
+  } catch (err) { results(err); }
 }
 
-async function cpuInfo() {
+async function cpuInfo(callback) {
   try {
     const {
       manufacturer,
@@ -92,7 +92,7 @@ async function cpuInfo() {
     } = await cpu();
 
     // show results
-    return {
+    callback({
       manufacturer,
       brand,
       speed,
@@ -102,11 +102,11 @@ async function cpuInfo() {
       vendor,
       family,
       model
-    };
-  } catch (err) { return err; }
+    });
+  } catch (err) { callback(err); }
 }
 
-async function ramMemInfo() {
+async function ramMemInfo(callback) {
   try {
     const {
       total,
@@ -117,17 +117,17 @@ async function ramMemInfo() {
     } = await mem();
 
     // show results
-    return {
+    callback({
       total_mem: `${(total / 1073741824).toFixed(2)} GB`,
       free_mem: `${(free / 1073741824).toFixed(2)} GB`,
       used_mem: `${(used / 1073741824).toFixed(2)} GB`,
       active_mem: `${(active / 1073741824).toFixed(2)} GB`,
       available_mem: `${(available / 1073741824).toFixed(2)} GB`
-    };
-  } catch (err) { return err; }
+    });
+  } catch (err) { callback(err); }
 }
 
-async function osDetail() {
+async function osDetail(callback) {
   try {
     const {
       hostname,
@@ -141,7 +141,7 @@ async function osDetail() {
     } = await osInfo();
 
     // show results
-    return {
+    callback({
       hostname,
       platform,
       distro,
@@ -150,11 +150,11 @@ async function osDetail() {
       arch,
       serial,
       uefi
-    };
-  } catch (err) { return err; }
+    });
+  } catch (err) { callback(err); }
 }
 
-async function diskInfo() {
+async function diskInfo(callback) {
   try {
     const disks = await diskLayout();
 
@@ -172,12 +172,12 @@ async function diskInfo() {
       interfaceType
     }));
 
-    return disksList;
+    callback(disksList);
 
-  } catch (err) { return err; }
+  } catch (err) { callback(err); }
 }
 
-async function controllerInfo() {
+async function controllerInfo(callback) {
   try {
     const { controllers } = await graphics();
 
@@ -193,11 +193,11 @@ async function controllerInfo() {
         : `${(vram / 1024).toFixed(2)} GB`
     }));
 
-    return controllersList;
-  } catch (err) { return err; }
+    callback(controllersList);
+  } catch (err) { callback(err); }
 }
 
-async function displayInfo() {
+async function displayInfo(callback) {
   try {
     const { displays } = await graphics();
 
@@ -215,11 +215,11 @@ async function displayInfo() {
       resolutionY
     }));
 
-    return displayList;
-  } catch (err) { return err; }
+    callback(displayList);
+  } catch (err) { callback(err); }
 }
 
-async function biosInfo() {
+async function biosInfo(callback) {
   try {
     const {
       releaseDate,
@@ -228,11 +228,11 @@ async function biosInfo() {
       version
     } = await bios();
 
-    return { releaseDate, vendor, revision, version };
-  } catch (err) { return err; }
+    callback({ releaseDate, vendor, revision, version });
+  } catch (err) { callback(err); }
 }
 
-const movieDB = async (api_key, query) => {
+const movieDB = async ({ api_key, query, results }) => {
   try {
     const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
       params: {
@@ -265,11 +265,11 @@ const movieDB = async (api_key, query) => {
       })
       .filter(({ release_date }) => release_date !== undefined && release_date !== "");
 
-    return movieData;
-  } catch (err) { return err; }
+    results(movieData);
+  } catch (err) { results(err); }
 };
 
-async function multipleStack(urls) {
+async function multipleStack({ urls, results }) {
   let result;
   const wappalyzer = new Wappalyzer();
   try {
@@ -285,10 +285,10 @@ async function multipleStack(urls) {
     );
   } catch (err) { result = err; }
   await wappalyzer.destroy();
-  return result;
+  results(result);
 }
 
-const pageSpeed = async (url) => {
+const pageSpeed = async ({ url, results }) => {
   try {
     const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
       params: {
@@ -310,11 +310,11 @@ const pageSpeed = async (url) => {
     const mobile = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
     const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
 
-    return {mobile, desktop};
-  } catch (err) { return err; }
+    results({ mobile, desktop });
+  } catch (err) { results(err); }
 };
 
-async function singleStack(url) {
+async function singleStack({ url, results }) {
   const wappalyzer = await new Wappalyzer;
 
   let result;
@@ -332,15 +332,155 @@ async function singleStack(url) {
       techWebsite: website,
       techCategories: categories.map(({ name }) => name).join(", ")
     }));
-  } catch (err) { result = err; }
+  } catch (err) { results(err); }
 
   await wappalyzer.destroy();
-  return result;
+  results(result);
+}
+
+async function twitchInfo({ query, token, clientID, results }) {
+  try {
+    const { data: twitchData } = await axios.get(`https://api.twitch.tv/helix/users?login=${query}`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Client-Id": clientID
+        }
+      });
+
+    results(twitchData.data);
+  } catch (err) { results(err); }
 }
 
+function scrape(url) {
+  let $;
+
+  const scraping = axios.create({
+    baseURL: url
+  });
+
+  const title = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      callback($("title").text());
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const images = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const imgs = $("img").map((i, el) => ({
+        imagePath: $(el).attr("src"),
+        imageTitle: $(el).attr("alt")
+      })).toArray();
+
+      callback(imgs);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const metadata = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const metadataList = $("meta").map((i, el) => ({
+        metaInfo: $(el).attr("name"),
+        metaContent: $(el).attr("content")
+      })).toArray()
+        .filter(({ metaInfo }) => metaInfo !== undefined);
+
+      callback(metadataList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const headings = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const headingList = $("h1, h2, h3, h4, h5, h6").map((i, el) => ({
+        headingTag: $(el).prop("tagName"),
+        headingText: $(el).text()
+      })).toArray();
+
+      callback(headingList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_heading = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableHeadList = $("th").map((i, el) => ({
+        headingRow: i,
+        text: $(el).text()
+      })).toArray();
+
+      callback(tableHeadList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_data = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableColumnList = $("td").map((i, el) => $(el).text()).toArray();
+
+      callback(tableColumnList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+
+  const links = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const linkList = $("a").map((i, el) => ({
+        url: $(el).attr("href"),
+        text: $(el).text()
+      })).toArray()
+        .filter(({ url }) => url.indexOf("#") !== 0);
+
+      callback(linkList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const cites = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const citeList = $("q, blockquote").map((i, el) => ({
+        citeTag: $(el).prop("tagName"),
+        citeLink: $(el).attr("cite"),
+        citeText: $(el).text()
+      })).toArray();
+      
+      callback(citeList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  return {
+    title,
+    images,
+    metadata,
+    headings,
+    table_heading,
+    table_data,
+    links,
+    cites
+  };
+}
 
 // exports
-exports = {
+module.exports = {
   animeSearch,
   bitlyInfo,
   cryptoMarket,
@@ -355,5 +495,7 @@ exports = {
   movieDB,
   multipleStack,
   pageSpeed,
-  singleStack
+  singleStack,
+  twitchInfo,
+  scrape
 };