stack-analyze 1.2.0 → 1.2.2

package/functions/cryptoList.js

@@ -6,23 +6,19 @@ import colors from "colors";
 import { printTable } from "console-table-printer";
 
 // currency format
-import { currency } from "../utils.js";
+import { currency, stackSave } from "../utils.js";
 
 /**
- *
  * @descripiton call the crypto market list
+ * @async
  * @returns { Promise<void> } - return results search
- *
  */
-const cryptoMarket = async () => {
+export default async function cryptoMarket() {
   try {
     // start crypto
     const { data } = await axios.get(
       "https://api.coingecko.com/api/v3/coins/markets", {
-        params: {
-          vs_currency: "usd",
-          per_page: 10
-        }
+        params: { vs_currency: "usd" }
       }
     );
 
@@ -37,18 +33,16 @@ const cryptoMarket = async () => {
       symbol,
       name,
       price: currency.format(current_price),
-      priceChanged: price_change_percentage_24h > 0 
-        ? colors.green(price_change_percentage_24h) 
-        : colors.red(price_change_percentage_24h),
+      priceChanged: `${price_change_percentage_24h.toFixed(2)} %`,
       lastUpdated: format(last_updated)
     }));
 
     // print table
-    printTable(coinList);
+    printTable(coinList.slice(0, 10));
+    
+    stackSave("crypto-list.json", JSON.stringify(coinList, null, 2));
   } catch (err) {
     // print err message
     console.error(colors.red(err.message));
   }
-};
-
-export default cryptoMarket;
+}

package/functions/gitUser.js

@@ -3,35 +3,35 @@ import { default as axios } from "axios";
 import { format } from "timeago.js";
 import colors from "colors";
 
+// save git user
+import { stackSave } from "../utils.js";
+
 /**
  *
  * @description call github info user
+ * @async
  * @param { string } user - get github user info
  * @returns { Promise<void> } - return results info
  *
  */
 export default async function githubInfo(user) {
   try {
-    const { data, status } = await axios.get(`https://api.github.com/users/${user}`);
+    const { data } = await axios.get(`https://api.github.com/users/${user}`);
 
-    if (status !== 404){
-      const info = {
-        username: data.login,
-        fullName: data.name === null ? "no info": data.name,
-        Email: data.email === null ? "no info": data.email,
-        userFollowers: data.followers,
-        userFollowing: data.following,
-        accountAge: format(data.created_at),
-        updated_info: format(data.updated_at),
-        twitter: data.twitter_username === null ? "no info": data.twitter_username,
-        repos: data.public_repos,
-        gists: data.public_gists
-      };
+    const info = {
+      username: data.login,
+      fullName: data?.name ?? "no info",
+      userFollowers: data.followers,
+      userFollowing: data.following,
+      accountAge: format(data.created_at),
+      twitter: data?.twitter_username ?? "no info",
+      repos: data.public_repos,
+      gists: data.public_gists
+    };
 
-      console.table(info);
-    } else {
-      console.info(colors.yellow(""+status));
-    }
+    console.table(info);
+    
+    stackSave(`${user}-info.json`, JSON.stringify(info, null, 2))
   } catch(err) {
     console.error(colors.red(err.message));
   }

package/functions/hardware.js

@@ -8,194 +8,113 @@ import {
   bios
 } from "systeminformation";
 import colors from "colors";
-import { printTable } from "console-table-printer";
 
-/** @type {Object.<string, function(): Promise<void>>} */
-const hardwareTools = {
-  async cpuInfo() {
-    console.clear();
+import { stackSave } from "../utils.js";
 
-    try {
-      const {
-        manufacturer,
-        brand,
-        speed,
-        cores,
-        physicalCores,
-        processors,
-        vendor,
-        family,
-        model
-      } = await cpu();
+/**
+ * 
+ * @param {number} size 
+ * @param {number} [base = 1073741824] 
+ * @returns {string}
+ */
+const gigabyteConvert = (size, base=1073741824) => (size / base).toFixed(2);
 
-      // show results
-      console.table({
-        manufacturer,
-        brand,
-        speed,
-        cores,
-        physicalCores,
-        processors,
-        vendor,
-        family,
-        model
-      });
-    } catch (err) {
-      console.error(colors.red(err.message));
-    }
-  },
-  async ramMemInfo() {
-    console.clear();
-
-    try {
-      const {
-        total,
-        free,
-        used,
-        active,
-        available
-      } = await mem();
+/**
+ * 
+ * @async
+ * @returns {Promise<void>}
+ */
+export default async function hardware() {
+  try {
+    // Map object
+    const hardware = new Map();
+    
+    // info
+    const biosInfo = await bios()
+    const cpuInfo = await cpu()
+    const ram = await mem()
+    const os = await osInfo()
+    const disks = await diskLayout()
+    const { displays, controllers } = await graphics();
 
-      // show results
-      console.table({
-        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) {
-      console.error(colors.red(err.message));
+    // omit falsy values
+    for(const key in biosInfo) {
+      if(!biosInfo[key]) {
+        delete biosInfo[key];
+      }
     }
-  },
-  async osDetail() {
-    console.clear();
 
-    try {
-      const {
-        hostname,
-        platform,
-        distro,
-        release,
-        kernel,
-        arch,
-        serial,
-        uefi
-      } = await osInfo();
-  
-      // show results
-      console.table({
-        hostname,
-        platform,
-        distro,
-        release,
-        kernel,
-        arch,
-        serial,
-        uefi
-      });
-    } catch (err) {
-      console.error(colors.red(err.message));
+    for(const key in cpuInfo) {
+      if(!cpuInfo[key]) {
+        delete cpuInfo[key];
+      }
     }
-  },
-  async diskInfo() {
-    console.clear();
-
-    try {
-      const disks = await diskLayout();
-  
-      const disksList = disks.map(({
-        type,
-        name,
-        vendor,
-        size,
-        interfaceType
-      }) => ({
-        type,
-        name,
-        vendor,
-        diskSize: `${(size / 1073741824).toFixed(2)} GB`,
-        interfaceType
-      }));
-  
-      printTable(disksList);
-  
-    } catch (err) {
-      console.error(colors.red(err.message));
+    
+    for(const key in cpuInfo.cache) {
+      if(!cpuInfo.cache[key]) {
+        delete cpuInfo.cache[key];
+      }
     }
-  },
-  async controllerInfo() {
-    console.clear();
 
-    try {
-      const { controllers } = await graphics();
-  
-      const controllersList = controllers.map(({
-        model,
-        vendor,
-        vram
-      }) => ({
-        model,
-        vendor,
-        vramSize: vram < 1024
-          ? `${vram} MB`
-          : `${(vram / 1024).toFixed(2)} GB`
-      }));
-  
-      // show results
-      printTable(controllersList);
-    } catch (err) {
-      console.error(colors.red(err.message));
+    for(const key in os) {
+      if(!os[key]) {
+        delete os[key];
+      }
     }
-  },
-  async displayInfo() {
-    console.clear();
 
-    try {
-      const { displays } = await graphics();
-  
-      const displayList = displays.map(({
-        model,
-        main,
-        connection,
-        resolutionX,
-        resolutionY
-      }) => ({
-        model,
-        main,
-        connection,
-        resolutionX,
-        resolutionY
-      }));
-  
-      // show results
-      printTable(displayList);
-    } catch (err) {
-      console.error(colors.red(err.message));
+    for(const key in ram) {
+      ram[key] = `${gigabyteConvert(ram[key])} GB`;
     }
-  },
-  async biosInfo() {
-    console.clear();
+    
+    disks.forEach(disk => {
+      for(const key in disk) {
+        if(!disk[key]) {
+          delete disk[key];
+        }
+        
+        if(typeof disk[key] === "number") {
+          disk[key] = `${gigabyteConvert(ram[key])} GB`;
+        }
+      }
+    });
+    
+    controllers.forEach(controller => {
+      for(const key in controller) {
+        if(!controller[key]) {
+          delete controller[key];
+        }
+        
+        if(typeof controller[key] === "number") {
+          controller[key] = controller[key] < 1024
+            ? `${controller[key]} MB`
+            : `${gigabyteConvert(controller[key])} GB`;
+        }
+      }
+    });
+    
+    displays.forEach(display => {
+      for(const key in display) {
+        if(!display[key]) {
+          delete display[key];
+        }
+      }
+    });
+    
+    // add values
+    hardware.set("bios", biosInfo);
+    hardware.set("cpu", cpuInfo);
+    hardware.set("ram", ram);
+    hardware.set("os", os);
+    hardware.set("disks", disks);
+    hardware.set("graphics", controllers);
+    hardware.set("displays", displays);
 
-    try {
-      const {
-        releaseDate,
-        vendor,
-        revision,
-        version
-      } = await bios();
-  
-      console.table({
-        releaseDate,
-        vendor,
-        bios_revision: revision === "" ? "no info" : revision,
-        version
-      });
-    } catch (err) {
-      console.error(colors.red(err.message));
-    }
+    // save file
+    stackSave("hardware.json", JSON.stringify(Object.fromEntries(hardware), null, 2));
+    
+    // finish
+    console.info("finish the hardware information file");
+  } catch (err) {
+    console.error(colors.red(err.message));
   }
-};
-
-// exports modules
-export default hardwareTools;
+}

package/functions/moviesInfo.js

@@ -3,12 +3,17 @@ import { default as axios } from "axios";
 import colors from "colors";
 import { printTable } from "console-table-printer";
 
+// save movies
+import { stackSave } from "../utils.js";
+
 /** 
  * @description movie info tool
+ * @async
  * @param { string } query - search any movie
+ * @param { string } token
  * @returns { Promise<void> } - return movie lisy
 */
-const movieDB = async (query, token) => {
+export default async function movieDB(query, token) {
   try {
     const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
       params: {
@@ -39,13 +44,12 @@ const movieDB = async (query, token) => {
         
         return primaryDate.getTime() - secondaryDate.getTime();
       })
-      .filter(({ release_date }) => release_date !== undefined && release_date !== "");
+      .filter((data) => data?.release_date);
 
     printTable(movieData);
+    
+    stackSave("movie-list.json", JSON.stringify(movieData, null, 2));
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-// export
-export default movieDB;
+}

package/functions/multipleStack.js

@@ -1,39 +1,31 @@
 // modules
-import figlet from "figlet";
-import Wappalyzer from "wappalyzer";
 import colors from "colors";
 import { printTable } from "console-table-printer";
+import { wappalyzer } from "../api/webApis.js";
 
 // list format
-import { listFormat } from "../utils.js";
+import { listFormat, stackSave } from "../utils.js";
 
 /**
  *
  * @description call multiple websites tech stack analyze
- * @param { string[] } urls - tech analyze in multiples websites
+ * @param { string[] } urlList - tech analyze in multiples websites
  * @returns { Promise<void> } - async results in multiples websites
  * 
  */
-const multipleStack = async (urls) => {
-  const wappalyzer = await new Wappalyzer();
-
+export default async function multipleStack(urlList) {
   try {
     await wappalyzer.init();
 
-    const results = await Promise.all(
-      urls.map(async (url) => {
-        const { technologies } = await wappalyzer.open(url).analyze();
-
-        return {
-          url,
-          technologies
-        };
-      }));
-
     console.info("multiple websites tech stack \n");
-    console.group();
-    // loop web site tech stack
-    results.forEach(({url, technologies}) => {
+    
+    const stacks = {};
+    
+    for await (const url of urlList) {
+      console.info(url.green);
+      
+      const { technologies } = await wappalyzer.open(url).analyze();
+
       const stackResult = technologies.map(({ 
         name,
         website,
@@ -47,16 +39,15 @@ const multipleStack = async (urls) => {
         };
       });
 
-      console.info(colors.green(figlet.textSync(url, "Small")));
-      console.group();
-      printTable(stackResult);
-      console.groupEnd();
-    });
+      printTable(stackResult.slice(0, 10));
+      
+      stacks[url] = stackResult;
+    }
+    
+    stackSave("multiple-stack.json", JSON.stringify(stacks, null, 2));
   } catch (err) {
     console.error(colors.red(err.message));
   }
 
   await wappalyzer.destroy();
-};
-
-export default multipleStack;
+}

package/functions/pageSpeed.js

@@ -1,116 +1,84 @@
 // modules
-import { default as axios } from "axios";
-import { SingleBar } from "cli-progress";
+import { MultiBar, Presets } from "cli-progress";
+import figlet from "figlet";
 import colors from "colors";
 
+// save file
+import { stackSave } from "../utils.js";
+
+// pagespeed api
+import { pagespeedApi } from "../api/webApis.js";
+
+const maxScore = 100;
+
+/**
+  * It takes a score and a bar, and returns a color based on the score
+  * @param {number} score - The score of the current test.
+  * @returns {string} A function that takes two parameters, score and bar.
+*/
+const barColor = score => {
+  const bar = "{bar}";
+
+  switch (true) {
+    case score === 1 || score <= 49:
+      return bar.red;
+    case score === 50 || score <= 89:
+      return bar.yellow;
+    case score >= 90 || score === maxScore:
+      return bar.green;
+    default:
+      return bar.magenta;
+  }
+};
+
 /**
  * @description async function mobile website pagespeed
+ * @async
  * @param { string } url - website from pagespeed mobile results
  * @returns { Promise<void> } - return async mobile results
  */
-const pageSpeed = async (url) => {
-  const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
-    params: {
-      url,
-      key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
-      strategy: "mobile"
-    }
-  });
+export default async function pagespeed(url) {
+  console.info(url.green);
 
-  const resDesktop = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
-    params: {
-      url,
-      key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
-      strategy: "desktop"
-    }
-  });
+  const multibar = new MultiBar({
+    format: "{type} | {bar} | {value}/{total}",
+    hideCursor: true,
+    clearOnComplete: false
+  }, Presets.legacy);
 
-  // extract results
-  const mobile = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
-  const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
+  try {
+    // start api
+    const { data: resMobile } = await pagespeedApi(url, "mobile");
+    const { data: resDesktop } = await pagespeedApi(url, "desktop");
 
-  // result pagespeed bar color
-  let b1;
-  let b2;
+    // extract results
+    const mobile = Math.round(resMobile.lighthouseResult.categories.performance.score * 100);
+    const desktop = Math.round(resDesktop.lighthouseResult.categories.performance.score * 100);
 
-  try {
+    // result pagespeed color bar
+    const b1 = multibar.create(maxScore, 0, { type: "mobile" }, {
+      format: `{type} | ${barColor(mobile)} | {value}/{total}`
+    });
+
+    const b2 = multibar.create(maxScore, 0, { type: "desktop" }, {
+      format: `{type} | ${barColor(desktop)} | {value}/{total}`
+    });
 
-    // valid results
-    switch (true) {
-      case (mobile === 1 || mobile <= 49):
-      case (desktop === 1 || desktop <= 49):
-        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 (mobile === 50 || mobile <= 89):
-      case (desktop === 50 || desktop <= 89):
-        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 (mobile >= 90 || mobile === 100):
-      case (desktop >= 90 || desktop === 100):
-        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 = 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
-    b1.stop();
-    b2.stop();
+    // stop multibar
+    multibar.stop();
+    
+    const resultTxt = `
+    ${figlet.textSync(url)} \n 
+    mobile: ${mobile}/100 \n 
+    desktop: ${desktop}/100
+    `;
+    
+    stackSave("pagespeed.txt", resultTxt);
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-export default pageSpeed;
+}