stack-analyze 1.1.4 → 1.1.7

package/functions/moviesInfo.js

@@ -0,0 +1,56 @@
+// modules
+import "../env/movie.env.js";
+import axios from "axios";
+import colors from "colors";
+
+// table module
+import movieList from "../models/movieTables.js";
+
+/** 
+ * @description movie info tool
+ * @param { string } query - search any movie
+ * @returns { Promise<void> } - return movie lisy
+*/
+const movieDB = async (query) => {
+  try {
+    const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
+      params: {
+        api_key: process.env.MOVIE_CODE,
+        query,
+        page: 1
+      }
+    });
+
+    const movieData = data.results
+      .map(({
+        title,
+        original_language,
+        popularity,
+        vote_average,
+        release_date
+      }) => ({
+        title,
+        original_language,
+        popularity,
+        vote_average,
+        release_date
+      }))
+      .sort((x, y) => {
+        // date values
+        const primaryDate = new Date(x.release_date);
+        const secondaryDate = new Date(y.release_date);
+        
+        return primaryDate.getTime() - secondaryDate.getTime();
+      })
+      .filter(({ release_date }) => release_date !== undefined && release_date !== "");
+
+    movieList.addRows(movieData);
+
+    movieList.printTable();
+  } catch (err) {
+    console.error(colors.red(err.message));
+  }
+};
+
+// export
+export default movieDB;

package/functions/multipleStack.js

@@ -1,8 +1,8 @@
 // modules
-const { textSync } = require("figlet");
-const Wappalyzer = require("wappalyzer");
-const { red, green } = require("colors");
-const { Table } = require("console-table-printer");
+import figlet from "figlet";
+import Wappalyzer from "wappalyzer";
+import colors from "colors";
+import stackTable from "../models/stackTables.js";
 
 /**
  *
@@ -14,26 +14,6 @@ const { Table } = require("console-table-printer");
 const multipleStack = async (urls) => {
   const wappalyzer = await new Wappalyzer();
 
-  const p = new Table({
-    columns: [
-      {
-        name: "techName",
-        alignment: "left",
-        color: "cyan"
-      },
-      {
-        name: "techWebsite",
-        alignment: "left",
-        color: "green"
-      },
-      {
-        name: "techCategories",
-        alignment: "left",
-        color: "cyan"
-      }
-    ]
-  });
-
   try {
     await wappalyzer.init();
 
@@ -61,17 +41,17 @@ const multipleStack = async (urls) => {
         techCategories: categories.map(({ name }) => name).join(", ")
       }));
 
-      console.info(green(textSync(url, "Small")));
+      console.info(colors.green(figlet.textSync(url, "Small")));
       console.group();
-      p.addRows(stackResult);
-      p.printTable();
+      stackTable.addRows(stackResult);
+      stackTable.printTable();
       console.groupEnd();
     });
   } catch (err) {
-    console.error(red(err.message));
+    console.error(colors.red(err.message));
   }
 
   await wappalyzer.destroy();
 };
 
-module.exports = multipleStack;
+export default multipleStack;

package/functions/pageSpeed.js

@@ -1,34 +1,7 @@
 // modules
-const axios = require("axios").default;
-const cliProgress = require("cli-progress");
-const colors = require("colors");
-
-/**
- * @description get color bar
- * @param { number } valueOne - get value data desktop
- * @param { number } valueTwo - get value data mobile
- * @param { any } bar - using bar
- * @returns { void }
- */
-const barColor = (valueOne, valueTwo, bar) => {
-  switch (true) {
-    case (valueOne === 1 || valueOne <= 49):
-    case (valueTwo === 1 || valueTwo <= 49):
-      colors.red(bar);
-      break;
-    case (valueOne === 50 || valueOne <= 89):
-    case (valueTwo === 50 || valueTwo <= 89):
-      colors.yellow(bar);
-      break;
-    case (valueOne >= 90 || valueOne === 100):
-    case (valueTwo >= 90 || valueTwo === 100):
-      colors.green(bar);
-      break;
-    default:
-      colors.bgMagenta(bar);
-      break;
-  }
-};
+import axios from "axios";
+import { SingleBar } from "cli-progress";
+import colors from "colors";
 
 /**
  * @description async function mobile website pagespeed
@@ -53,52 +26,91 @@ const pageSpeed = async (url) => {
   });
 
   // extract results
-  const movil = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
+  const mobile = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
   const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
 
   // result pagespeed bar color
-  const multibar = new cliProgress.MultiBar({
-    format: " {bar} | {text} | {value}/{total}",
-    clearOnComplete: false,
-    hideCursor: true,
-    barCompleteChar: "\u2588",
-    barIncompleteChar: "\u2591",
-  }, cliProgress.Presets.rect);
-
-  // add bars
-  const b1 = multibar.create(100, 0);
-  const b2 = multibar.create(100, 0);
+  let b1;
+  let b2;
 
   try {
 
     // valid results
     switch (true) {
-      case (movil === 1 || movil <= 49):
+      case (mobile === 1 || mobile <= 49):
       case (desktop === 1 || desktop <= 49):
-        b1.update(movil, { text: "mobile result".red });
-        b2.update(desktop, { text: "desktop result".red });
+        b1 = new SingleBar({
+          format: "Mobile Result | {bar} || {value}/{total} || bad".red,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
+        b2 = new SingleBar({
+          format: "Desktop Result | {bar} || {value}/{total} || bad".red,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
         break;
-      case (movil === 50 || movil <= 89):
+      case (mobile === 50 || mobile <= 89):
       case (desktop === 50 || desktop <= 89):
-        b1.update(movil, { text: "mobile result".yellow });
-        b2.update(desktop, { text: "desktop result".yellow });
+        b1 = new SingleBar({
+          format: "Mobile Result | {bar} || {value}/{total} || decent".yellow,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
+        b2 = new SingleBar({
+          format: "Desktop Result | {bar} || {value}/{total} || decent".yellow,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
         break;
-      case (movil >= 90 || movil === 100):
+      case (mobile >= 90 || mobile === 100):
       case (desktop >= 90 || desktop === 100):
-        b1.update(movil, { text: "mobile result".green });
-        b2.update(desktop, { text: "desktop result".green });
+        b1 = new SingleBar({
+          format: "Mobile Result | {bar} || {value}/{total} || excelent".green,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
+        b2 = new SingleBar({
+          format: "Desktop Result | {bar} || {value}/{total} || excelent".green,
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
         break;
       default:
-        b1.update(movil, { text: "mobile result" });
-        b2.update(desktop, { text: "desktop result" });
+        b1 = new SingleBar({
+          format: "Mobile Result | {bar} || {value}/{total} || undifined",
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
+        b2 = new SingleBar({
+          format: "Desktop Result | {bar} || {value}/{total} || undifined",
+          barCompleteChar: "\u2588",
+          barIncompleteChar: "\u2591",
+          hideCursor: true
+        });
         break;
     }
+    
+    // initials bars
+    b1.start(100, 0);
+    b2.start(100, 0);
+    
+    b1.update(mobile);
+    b2.update(desktop);
 
     // stop all bars
-    multibar.stop();
+    b1.stop();
+    b2.stop();
   } catch (err) {
-    console.error(err.message.red);
+    console.error(colors.red(err.message));
   }
 };
 
-module.exports = pageSpeed;
+export default pageSpeed;

package/functions/singleStack.js

@@ -1,8 +1,8 @@
 // module
-const Wappalyzer = require("wappalyzer");
-const { textSync } = require("figlet");
-const { red, green } = require("colors");
-const { Table } = require("console-table-printer");
+import Wappalyzer from "wappalyzer";
+import figlet from "figlet";
+import colors from "colors";
+import stackTable from "../models/stackTables.js";
 
 /**
  * 
@@ -11,30 +11,9 @@ const { Table } = require("console-table-printer");
  * @returns { Promise<void> } - return async results single web
  * 
  */
-async function singleStack(url) {
+export default async function singleStack(url) {
   const wappalyzer = await new Wappalyzer;
 
-  const p = new Table({
-    columns: [
-      {
-        name: "techName",
-        alignment: "left",
-        color: "cyan"
-      },
-      {
-        name: "techWebsite",
-        alignment: "left",
-        color: "green"
-      },
-      {
-        name: "techCategories",
-        alignment: "left",
-        color: "cyan"
-      }
-    ]
-
-  });
-
   try {
     await wappalyzer.init();
 
@@ -50,16 +29,14 @@ async function singleStack(url) {
       techCategories: categories.map(({ name }) => name).join(", ")
     }));
 
-    console.info(green(textSync(url)));
+    console.info(colors.green(figlet.textSync(url)));
 
-    p.addRows(stackResult);
+    stackTable.addRows(stackResult);
 
-    p.printTable();
+    stackTable.printTable();
   } catch (err) {
-    console.error(red(err.message));
+    console.error(colors.red(err.message));
   }
 
   await wappalyzer.destroy();
 }
-
-module.exports = singleStack;

package/functions/twitch.js

@@ -0,0 +1,46 @@
+// modules
+import "../env/twitchID.env.js";
+import axios from "axios";
+import { format } from "timeago.js";
+import colors from "colors";
+
+// table
+import twitchTable from "../models/twitchTables.js";
+
+/**
+ * 
+ * @description twitch user info
+ * @param {string} twitchUser - twitch user for search
+ * @param {string} apiToken - twitch api token
+ * @returns { Promise<void> } - return twitch results
+ */
+const twitchInfo = async (twitchUser, apiToken) => {
+
+  try {
+    const { data: twitchData } = await axios.get(`https://api.twitch.tv/helix/users?login=${twitchUser}`, {
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+        "Client-Id": process.env.CLIENT_ID
+      }
+    });
+
+    const result = twitchData.data.map(({
+      display_name,
+      broadcaster_type,
+      view_count,
+      created_at
+    }) => ({
+      display_name,
+      broadcaster_type,
+      view_count,
+      createdTime: format(created_at)
+    }));
+
+    twitchTable.addRows(result);
+    twitchTable.printTable();
+  } catch (err) {
+    console.error(colors.red(err));
+  }
+};
+
+export default twitchInfo;

package/hash/aboutOpts.js

@@ -0,0 +1,53 @@
+// print table
+import { printTable } from "console-table-printer";
+
+// tables models 
+import {
+  youtubeDevTable,
+  ideasTable
+} from "../models/aboutTables.js";
+
+// about sections
+import {
+  aboutApp,
+  developers,
+  twitch,
+  projects,
+  ideas,
+  youtubeDev
+} from "../about.js";
+
+/** @type {{ main_info(): void, lineup(): void, youtube_recomendation(): void, twitch_recomendation(): void, projects_recomendation(): void, tools_ideas(): void }} */
+const aboutTool = {
+  main_info() {
+    console.clear();
+    console.table(aboutApp);
+  },
+  lineup() {
+    console.clear();
+    printTable(developers.map((dev, i) => ({ index: i + 1, dev })));
+  },
+  youtube_recomendation() {
+    console.clear();
+    youtubeDevTable.addRows(youtubeDev);
+    youtubeDevTable.printTable();
+  },
+  twitch_recomendation() {
+    console.clear();
+    const streamers = twitch.map((streamer, i) => ({ index: i + 1, streamer }));
+    printTable(streamers);
+  },
+  projects_recomendation() {
+    console.clear();
+    const proyectsReccomend = projects.map((project, i) => ({ index: i + 1, project }));
+    printTable(proyectsReccomend);
+  },
+  tools_ideas() {
+    console.clear();
+    ideasTable.addRows(ideas);
+    ideasTable.printTable();
+  }
+};
+
+// export hash
+export default aboutTool;

package/hash/hardwareTools.js

@@ -0,0 +1,47 @@
+// hardware modules
+import {
+  cpuInfo,
+  ramMemInfo,
+  osDetail,
+  diskInfo,
+  controllerInfo,
+  displayInfo,
+  biosInfo
+} from "../functions/hardware.js";
+
+/**
+ * @type {{ cpu(): void, ram_memory(): void, os(): void, disk(): void, controller(): void, display(): void, bios(): void }}
+ */
+const hardwareTools = {
+  cpu() {
+    console.clear();
+    cpuInfo();
+  },
+  ram_memory() {
+    console.clear();
+    ramMemInfo();
+  },
+  os() {
+    console.clear();
+    osDetail();
+  },
+  disk() {
+    console.clear();
+    diskInfo();
+  },
+  controller() {
+    console.clear();
+    controllerInfo();
+  },
+  display() {
+    console.clear();
+    displayInfo();
+  },
+  bios() {
+    console.clear();
+    biosInfo();
+  }
+};
+
+// exports
+export default hardwareTools;

package/hash/infoTools.js

@@ -0,0 +1,112 @@
+// modules
+import inquirer from "inquirer";
+
+// github info
+import githubInfo from "../functions/gitUser.js";
+
+// anime search
+import animeSearch from "../functions/animeInfo.js";
+
+// crypto market
+import cryptoMarket from "../functions/cryptoList.js";
+
+// bitly
+import bitlyInfo from "../functions/bitly.js";
+
+// movies
+import movieDB from "../functions/moviesInfo.js";
+
+// twitch
+import twitchInfo from "../functions/twitch.js";
+
+
+/** 
+ * @type {{ github_info(): Promise<void>, anime_search(): Promise<void>, crypto_market(): void, bitly_info(): Promise<void>, movie_info(): Promise<void>, twitch_info(): Promise<void>}} 
+*/
+const infoTools = {
+  async github_info() {
+    const { user } = await inquirer.prompt({
+      name: "user",
+      message: "enter a github user"
+    });
+
+    if (user !== "") {
+      console.clear();
+      githubInfo(user);
+    } else {
+      console.error("please the github username is required".red);
+    }
+  },
+  async anime_search() {
+    const { anime } = await inquirer.prompt({
+      name: "anime",
+      message: "enter a anime, movie or ova search"
+    });
+
+    if (anime !== "") {
+      console.clear();
+      animeSearch(anime);
+    } else {
+      console.error("please the anime is required".red);
+    }
+  },
+  crypto_market() {
+    console.clear();
+    cryptoMarket();
+  },
+  async bitly_info() {
+    console.clear();
+    const { link } = await inquirer.prompt([
+      {
+        name: "link",
+        message: "enter a bitly link without http|https",
+      }
+    ]);
+
+    if (link !== "") {
+      console.clear();
+      bitlyInfo(link);
+    } else {
+      console.error("bitly link is required".red);
+    }
+  },
+  async movie_info() {
+    const { query } = await inquirer.prompt([
+      {
+        name: "query",
+        message: "please search a movie search",
+      }
+    ]);
+
+    if (query !== "") {
+      console.clear();
+      movieDB(query);
+    } else {
+      console.error("please the movie is required".red);
+    }
+  },
+  async twitch_info() {
+    const { user, twitch_token } = await inquirer.prompt([
+      {
+        name: "user",
+        message: "get twitch user"
+      },
+      {
+        name: "twitch_token",
+        message: "enter a twitch token without the key Bearer",
+        type: "password",
+        mask: "?"
+      }
+    ]);
+
+    if (user !== "" && twitch_token !== "") {
+      console.clear();
+      twitchInfo(user, twitch_token);
+    } else {
+      console.error("twitch info fields is required".red);
+    }
+  }
+};
+
+// exports
+export default infoTools;

package/hash/mainTools.js

@@ -0,0 +1,67 @@
+// modules
+import inquirer from "inquirer";
+import figlet from "figlet";
+import colors from "colors";
+
+// analyze web
+import singleStack from "../functions/singleStack.js";
+import multipleStack from "../functions/multipleStack.js";
+
+// pagespeed web
+import pageSpeed from "../functions/pageSpeed.js";
+
+/**
+ * @type {{ single(): Promise<void>, multiple(): Promise<void>,  pagespeed(): Promise<void> }}
+ */
+const mainTools = {
+  async single() {
+    console.clear();
+    const { url } = await inquirer.prompt({
+      name: "url",
+      message: "enter url for analyze the tech stack:"
+    });
+
+    url.indexOf("http") === 0
+      ? singleStack(url)
+      : console.error("please insert a URL with parameter http:// or https://".red);
+  },
+  async multiple() {
+    console.clear();
+    const { urls } = await inquirer.prompt({
+      name: "urls",
+      message: "enter URLs for analyze the tech stacks with whitespace without quotes example 'http://example.com https://nodejs.org': \n"
+    });
+
+    if (
+      urls.match(/(http|https)/g) !== null ||
+      urls.match(/(http|https)/g) >= 2
+    ) {
+      const websites = urls.split(" ");
+      console.clear();
+      multipleStack(websites);
+    } else {
+      console.error("please in each URL insert a website the parameter https:// or http://".red);
+    }
+  },
+  async pagespeed() {
+    console.clear();
+    const { speedWeb } = await inquirer.prompt({
+      name: "speedWeb",
+      message: "insert URL for page speed analyze:"
+    });
+
+    if (speedWeb.indexOf("http") === 0) {
+      console.clear();
+      console.info(colors.green(figlet.textSync(speedWeb)));
+
+      // start pagespeed results mobile
+      figlet.textSync(speedWeb, "Small");
+      pageSpeed(speedWeb);
+    } else {
+      console.error("please insert a URL with parameter https;// or http://".red);
+    }
+  }
+};
+
+// export
+export default mainTools;