stack-analyze 1.2.0 → 1.2.2

package/cli.js

@@ -1,432 +1,191 @@
 #!/usr/bin/env node
-
-// modules
-import { performance } from "perf_hooks";
+import Gauge from "gauge";
+import colors from "colors";
 import inquirer from "inquirer";
 import figlet from "figlet";
-import colors from "colors";
 
-// hash tables
-import hardwareTools from "./functions/hardware.js";
+import webTools from "./hash/webTools.js";
+import queryTools from "./hash/queryTools.js";
+import infoTools from "./hash/infoTools.js";
+import utilityTools from "./hash/utilityTools.js";
 import aboutTool from "./about.js";
 
-import singleStack from "./functions/singleStack.js";
-import multipleStack from "./functions/multipleStack.js";
-import pageSpeed from "./functions/pageSpeed.js";
-import githubInfo from "./functions/gitUser.js";
-import animeSearch from "./functions/animeInfo.js";
-import cryptoMarket from "./functions/cryptoList.js";
-import bitlyInfo from "./functions/bitly.js";
-import movieDB from "./functions/moviesInfo.js";
-import twitchInfo from "./functions/twitch.js";
-import scrape from "./functions/scraping.js";
-import genPassword from "./functions/password.js";
+import {
+  menuOpts,
+  menuQueryOpts,
+  menuWebOpts,
+  menuAboutOpts,
+  menuInfoOpts,
+  menuUtilityOpts
+} from "./utils.js";
+
+const [gauge, totalTime, pageSize] = [new Gauge(), 1e4, 9];
+
+/** @returns {void} */
+const exitCli = () => {
+  console.clear();
+  console.info("thanks for use stack-analyze".green);
+};
 
 /**
- * @description web scraping menu
- * @return { Promise<void>} web scraping options
+ * @async
+ * @returns {Promise<void>}
  */
-async function scrapingOpts (url) {
-  console.info("web:", url);
-  
-  const { option } = await inquirer.prompt({
+async function webOpts() {
+  const { web } = await inquirer.prompt({
     type: "list",
-    name: "option",
-    message: "select a options for scraping",
-    pageSize: 15,
-    choices: [
-      "pageTitle",
-      "pageImages",
-      "pageMetadata",
-      "pageHeadings",
-      "pageTableHead",
-      "pageTableData",
-      "pageLinks",
-      "pageCites",
-      "exit to main menu"
-    ]
+    pageSize,
+    name: "web",
+    message: "enter a web tool option",
+    choices: menuWebOpts
   });
-    
-  const {
-    cites,
-    headings,
-    images,
-    links,
-    title,
-    metadata,
-    table_data,
-    table_heading
-  } = scrape(url);
-  
-  const timeScrape = 2000;
 
-  /** @type {Object.<string, function(): void>} */
-  const scrapeOpt = {
-    pageTitle() {
-      title();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageImages() {
-      images();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageMetadata() {
-      metadata();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageHeadings() {
-      headings();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageTableHead() {
-      table_heading();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageTableData() {
-      table_data();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageLinks() {
-      links();
-      setTimeout(returnQuestion, timeScrape);
-    },
-    pageCites() {
-      cites();
-      setTimeout(returnQuestion, timeScrape);
-    },
-  };
-
-  option === "exit to main menu" 
-    ? question() 
-    : scrapeOpt[option]();
+  web !== "return main menu"
+    ? webTools[web](returnMain)
+    : mainMenu();
 }
 
 /**
- * @description web scraping menu
- * @return { Promise<void>} web scraping options
+ * @async
+ * @returns {Promise<void>}
  */
-async function scrapingLink() {
-  console.clear();
-  const { link } = await inquirer.prompt({
-    type: "input",
-    name: "link",
-    message: "enter a web scraping options?"
+async function infoOpts() {
+  const { info } = await inquirer.prompt({
+    type: "list",
+    pageSize,
+    name: "info",
+    message: "enter a info tool option",
+    choices: menuInfoOpts
   });
 
-  if(link.indexOf("http") === -1) {
-    console.error("https:// or http:// is required".red);
-    setTimeout(question, 5000);
-  } else {
-    scrapingOpts(link);
-  }
+  info === "return main menu"
+    ? mainMenu()
+    : infoTools[info](returnMain);
 }
 
-/** 
- * @description about menu
- * @return { Promise<void> } about option sections answer
+/**
+ * @async
+ * @returns {Promise<void>}
  */
-async function aboutOpts() {
-  const { about } = await inquirer.prompt({
+async function queryOpts() {
+  const { query } = await inquirer.prompt({
     type: "list",
-    pageSize: 9,
-    name: "about",
-    message: "select about option info",
-    choices: [
-      "mainInfo",
-      "lineup",
-      "youtubeRecomendation",
-      "twitchRecomendation",
-      "projectsRecomendation",
-      "return to main menu"
-    ]
+    pageSize,
+    name: "query",
+    message: "enter a query tool option",
+    choices: menuQueryOpts
   });
 
-  if (about !== "return to main menu") {
-    aboutTool[about]();
-    setTimeout(aboutOpts, 1000);
-  } else {
-    question();
-  }
+  query === "return main menu"
+    ? mainMenu()
+    : queryTools[query](returnMain);
 }
 
 /**
- * 
- * @description call the async function return list to question list
- * @return { Promise<void> } - return in boolean a result question list
- * 
+ * @async
+ * @returns {Promise<void>}
  */
-async function returnQuestion() {
-  try {
-    const anw = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "return",
-        message: "do you want go to the tools menu?",
-      }
-    ]);
+async function utilityOpts() {
+  const { utility } = await inquirer.prompt({
+    type: "list",
+    pageSize,
+    name: "utility",
+    message: "enter a utility tool option",
+    choices: menuUtilityOpts
+  });
 
-    if (anw.return) {
-      console.clear();
-      question();
-    } else {
-      console.clear();
-      console.info("thanks for use stack-analyze".green);
-    }
-  } catch (err) {
-    console.error(colors.red(err.message));
-  }
+  utility === "return main menu"
+    ? mainMenu()
+    : utilityTools[utility](returnMain);
 }
 
 /**
- * @description This is a hash table with the options of the tools menu. 
- * @type {Object.<string, function(): void>}
+ * @async
+ * @returns {Promise<void>}
  */
-const toolsOpts = {
-  single() {
-    console.clear();
-    inquirer.prompt({
-      name: "url",
-      message: "enter url for analyze the tech stack:"
-    }).then(({ url }) => {
-      if (url.indexOf("http") === 0) {
-        singleStack(url);
-        const timeEnd = performance.now();
-        setTimeout(returnQuestion, timeEnd);
-      } else {
-        console.error("please insert a URL with parameter http:// or https://".red);
-      }
-    });
-  },
-  multiple() {
-    console.clear();
-    inquirer.prompt({
-      name: "urls",
-      message: "enter URLs for analyze the tech stacks with whitespace without quotes example 'http://example.com https://nodejs.org': \n"
-    }).then(({ urls }) => {
-
-      if (
-        urls.match(/(http|https)/g) !== null ||
-        urls.match(/(http|https)/g) >= 2
-      ) {
-        const websites = urls.split(" ");
-        console.clear();
-        multipleStack(websites);
-        const timeEnd = performance.now();
-        setTimeout(returnQuestion, timeEnd);
-      } else {
-        console.error("please in each URL insert a website the parameter https:// or http://".red);
-      }
-    });
-  },
-  pagespeed() {
-    console.clear();
-    inquirer.prompt({
-      name: "speedWeb",
-      message: "insert URL for page speed analyze:"
-    }).then(({ speedWeb }) => {
-      if (speedWeb.indexOf("http") === 0) {
-        console.clear();
-
-        // start pagespeed results mobile
-        figlet.textSync(speedWeb, "Small");
-        pageSpeed(speedWeb);
-        const timeEnd = performance.now();
-        setTimeout(returnQuestion, timeEnd);
-      } else {
-        console.error("please insert a URL with parameter https;// or http://".red);
-      }
-    });
-  },
-  github_info() {
-    console.clear();
-    inquirer.prompt({
-      name: "user",
-      message: "enter a github user"
-    }).then(({ user }) => {
-      if (user !== "") {
-        console.clear();
-        githubInfo(user);
-        setTimeout(returnQuestion, 2000);
-      } else {
-        console.error("please the github username is required".red);
-      }
-    });
-  },
-  anime_search() {
-    console.clear();
-    inquirer.prompt({
-      name: "anime",
-      message: "enter a anime, movie or ova search"
-    }).then(({ anime }) => {
-      if (anime !== "") {
-        console.clear();
-        animeSearch(anime);
-        setTimeout(returnQuestion, 2000);
-      } else {
-        console.error("please the anime is required".red);
-      }
-    });
-  },
-  crypto_market() {
-    console.clear();
-    cryptoMarket();
-    setTimeout(returnQuestion, 5000);
-  },
-  password() {
-    console.clear();
-    genPassword();
-    setTimeout(returnQuestion, 3000);
-  },
-  bitly_info() {
-    console.clear();
-    inquirer.prompt([
-      {
-        name: "link",
-        message: "enter a bitly link without http|https",
-      },
-      {
-        name: "token",
-        message: "enter a bitly token",
-        type: "password",
-        mask: "?"
-      }
-    ])
-      .then(({ link, token }) => {
-        bitlyInfo(link, token);
-        setTimeout(returnQuestion, 3000);
-      });
-  },
-  movie_info() {
-    console.clear();
-    inquirer.prompt([
-      {
-        name: "api_key",
-        message: "insert api key",
-        type: "password",
-        mask: "?"
-      },
-      {
-        name: "query",
-        message: "please search a movie search",
-      }
-    ]).then(({ api_key, query }) => {
-      console.clear();
-      movieDB(query, api_key);
-      setTimeout(returnQuestion, 3000);
-    });
-  },
-  twitch_info() {
-    console.clear();
-    inquirer.prompt([
-      {
-        name: "user",
-        message: "get twitch user"
-      },
-      {
-        name: "twitch_client",
-        message: "enter a twitch token client",
-        type: "password",
-        mask: "*"
-      },
-      {
-        name: "twitch_token",
-        message: "enter a twitch token without the key Bearer",
-        type: "password",
-        mask: "?"
-      }
-    ]).then(({ user, twitch_client, twitch_token }) => {
-      if (user !== "" && twitch_client !== "" && twitch_token !== "") {
-        console.clear();
-        twitchInfo(user, twitch_client, twitch_token);
-        setTimeout(returnQuestion, 3000);
-      } else {
-        console.error("twitch info fields is required".red);
-      }
-    });
-  }
-};
-
-/**
- * @description call hardware information options
- * @returns { Promise<void> } hardware options tool
- */
-async function hardwareOpts() {
-  const { hardware } = await inquirer.prompt({
+async function aboutOpts() {
+  const { about } = await inquirer.prompt({
     type: "list",
-    name: "hardware",
-    pageSize: 9,
-    message: "select a hardware-information option:",
-    choices: [
-      "cpuInfo",
-      "ramMemInfo",
-      "osDetail",
-      "diskInfo",
-      "controllerInfo",
-      "displayInfo",
-      "biosInfo",
-      "exit to main menu"
-    ]
+    pageSize,
+    name: "about",
+    message: "select about option info",
+    choices: menuAboutOpts
   });
 
-  if (hardware !== "exit to main menu") {
-    hardwareTools[hardware]();
-    setTimeout(hardwareOpts, 1000);
-  } else {
-    question();
-  }
+  about !== "return main menu"
+    ? aboutTool[about](aboutOpts)
+    : mainMenu();
 }
 
 /**
- * 
- * @description call the function question raw list options
- * @returns { Promise<void> } return exit question
- * 
+ * @async
+ * @returns {Promise<void>}
  */
-async function question() {
+async function mainMenu() {
   console.clear();
   console.info(colors.yellow(figlet.textSync("stack-analyze")));
-  const { analyze } = await inquirer.prompt({
+
+  const { option } = await inquirer.prompt({
     type: "list",
-    pageSize: 15,
-    name: "analyze",
+    name: "option",
     message: "what option do you want to analyze stack",
-    choices: [
-      "single",
-      "multiple",
-      "pagespeed",
-      "github_info",
-      "anime_search",
-      "crypto_market",
-      "bitly_info",
-      "movie_info",
-      "twitch_info",
-      "hardware tools",
-      "scraping",
-      "password",
-      "about",
-      "exit"
-    ]
+    choices: menuOpts
   });
 
-  switch (analyze) {
-    case "hardware tools":
-      hardwareOpts();
-      break;
-    case "about":
-      aboutOpts();
-      break;
-    case "scraping":
-      scrapingLink();
-      break;
-    case "exit":
+  const menuList = {
+    web() {
       console.clear();
-      console.info("thanks for use stack-analyze".green);
-      break;
-    default:
-      toolsOpts[analyze]();
-      break;
+      webOpts();
+    },
+    info() {
+      console.clear();
+      infoOpts();
+    },
+    query() {
+      console.clear();
+      queryOpts();
+    },
+    utility() {
+      console.clear();
+      utilityOpts();
+    },
+    about() {
+      console.clear();
+      aboutOpts();
+    }
+  };
+
+  option !== "exit" ? menuList[option]() : exitCli();
+}
+
+/**
+ * @async
+ * @returns {Promise<void>}
+ */
+async function returnMain() {
+  try {
+    const { returnMain } = await inquirer.prompt({
+      type: "confirm",
+      name: "returnMain",
+      message: "do you want go to the main menu?",
+    });
+
+    returnMain ? mainMenu() : exitCli();
+  } catch (err) {
+    console.error(colors.bgRed(err.message));
   }
 }
 
-// call the message title and question list
-question();
+for (let i = 50; i < totalTime; i += 50) {
+  const percentage = i / totalTime;
+
+  setTimeout(() => {
+    gauge.pulse();
+    gauge.show(`Loading app... ${percentage * 100}%`.random, percentage);
+  }, i);
+}
+
+setTimeout(() => {
+  gauge.hide();
+  mainMenu();
+}, totalTime);

package/functions/animeInfo.js

@@ -4,22 +4,22 @@ import { format } from "timeago.js";
 import colors from "colors";
 import { printTable } from "console-table-printer";
 
+// save anime
+import { stackSave } from "../utils.js";
+
 /**
  *
  * @description call the anime serach info
- * @param { string } query - get query results
+ * @async
+ * @param { string } q - get query results
  * @returns { Promise<void> } - return results serach
  *
  */
-const animeSearch = async (query) => {
-  /* error manager */
+export default async function animeSearch(q) {
   try {
     // call api
     const { data } = await axios.get("https://api.jikan.moe/v4/anime", {
-      params: {
-        q: query,
-        limit: 10
-      }
+      params: { q }
     });
 
     const animeData = data.data.map(({
@@ -30,17 +30,16 @@ const animeSearch = async (query) => {
       type }) => ({
       title,
       type,
-      totalEpisodes: episodes ?? 1,
+      totalEpisodes: episodes || "current",
       debutDate: format(aired.from),
-      finalDate: aired.to !== null
+      finalDate: aired?.to
         ? format(aired.to)
         : status
     }));
 
 
-    printTable(animeData);
+    printTable(animeData.slice(0, 10));
+    
+    stackSave(`${q}-results.json`, JSON.stringify(animeData, null, 2));
   } catch (err) { console.error(colors.red(err.message)); }
-};
-
-// exports module
-export default animeSearch;
+}

package/functions/bitly.js

@@ -3,20 +3,23 @@ import { default as axios } from "axios";
 import { format } from "timeago.js";
 import colors from "colors";
 
+// save bitly
+import { stackSave } from "../utils.js";
+
 /**
  *
  * @description call the bitly info data
+ * @async
  * @param { string } link - link for search info
+ * @param { string } token - bitly api token is required
  * @returns { Promise<void> } - return results serach
  *
  */
-const bitlyInfo = async (link, token) => {
+export default async function bitlyInfo(link, token) {
   try {
-    const { data, status } = await axios.post(
+    const { data } = await axios.post(
       "https://api-ssl.bitly.com/v4/expand",
-      {
-        bitlink_id: link
-      },
+      { bitlink_id: link },
       {
         headers: {
           Authorization: `Bearer ${token}`,
@@ -25,17 +28,14 @@ const bitlyInfo = async (link, token) => {
       }
     );
 
-    status === 404
-      ? console.info("no found link".green)
-      : console.table({
-        created_link: format(data.created_at),
-        bitly_link: data.link,
-        link: data.long_url
-      });
+    console.table({
+      created_link: format(data.created_at),
+      bitly_link: data.link,
+      link: data.long_url
+    });
+    
+    stackSave("bitly.json", JSON.stringify(data, null, 2));
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-// export
-export default bitlyInfo;
+}