stack-analyze 1.1.9 → 1.2.1

package/functions/animeInfo.js

@@ -7,40 +7,34 @@ import { printTable } from "console-table-printer";
 /**
  *
  * @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/v3/search/anime", {
-      params: {
-        q: query,
-        limit: 10
-      }
+    const { data } = await axios.get("https://api.jikan.moe/v4/anime", {
+      params: { q }
     });
 
-    const animeData = data.results.map(({
+    const animeData = data.data.map(({
       title,
       episodes,
-      start_date,
-      end_date,
+      aired,
+      status,
       type }) => ({
       title,
       type,
-      episodes,
-      debutDate: format(start_date),
-      finalDate: end_date !== null
-        ? format(end_date)
-        : "current date"
+      totalEpisodes: episodes || "current",
+      debutDate: format(aired.from),
+      finalDate: aired?.to
+        ? format(aired.to)
+        : status
     }));
 
 
-    printTable(animeData);
+    printTable(animeData.slice(0, 10));
   } catch (err) { console.error(colors.red(err.message)); }
-};
-
-// exports module
-export default animeSearch;
+}

package/functions/bitly.js

@@ -6,17 +6,17 @@ import colors from "colors";
 /**
  *
  * @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 +25,12 @@ 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
+    });
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-// export
-export default bitlyInfo;
+}

package/functions/cryptoList.js

@@ -9,20 +9,16 @@ import { printTable } from "console-table-printer";
 import { currency } 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,14 @@ 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));
   } catch (err) {
     // print err message
     console.error(colors.red(err.message));
   }
-};
-
-export default cryptoMarket;
+}

package/functions/gitUser.js

@@ -6,32 +6,27 @@ import colors from "colors";
 /**
  *
  * @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 res = await axios.get(`https://api.github.com/users/${user}`);
+    const { data } = await axios.get(`https://api.github.com/users/${user}`);
 
-    if (res.status !== 404){
-      const info = {
-        username: res.data.login,
-        fullName: res.data.name === null ? "no info": res.data.name,
-        Email: res.data.email === null ? "no info": res.data.email,
-        userFollowers: res.data.followers,
-        userFollowing: res.data.following,
-        accountAge: format(res.data.created_at),
-        updated_info: format(res.data.updated_at),
-        twitter: res.data.twitter_username === null ? "no info": res.data.twitter_username,
-        repos: res.data.public_repos,
-        gists: res.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(res.status.toString()));
-    }
+    console.table(info);
   } catch(err) {
     console.error(colors.red(err.message));
   }

package/functions/hardware.js

@@ -10,9 +10,18 @@ import {
 import colors from "colors";
 import { printTable } from "console-table-printer";
 
-/** @type {Object.<string, function(): Promise<void>>} */
+const timeout = 1e3;
+
+/**
+ * 
+ * @param {number} size 
+ * @param {number} [base = 1073741824] 
+ * @returns {string}
+ */
+const gigabyteConvert = (size, base=1073741824) => (size / base).toFixed(2);
+
 const hardwareTools = {
-  async cpuInfo() {
+  async cpuInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -43,8 +52,9 @@ const hardwareTools = {
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async ramMemInfo() {
+  async ramMemInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -58,17 +68,18 @@ const hardwareTools = {
 
       // 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`
+        total_mem: `${gigabyteConvert(total)} GB`,
+        free_mem: `${gigabyteConvert(free)} GB`,
+        used_mem: `${gigabyteConvert(used)} GB`,
+        active_mem: `${gigabyteConvert(active)} GB`,
+        available_mem: `${gigabyteConvert(available)} GB`
       });
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async osDetail() {
+  async osDetail(refreshCallback) {
     console.clear();
 
     try {
@@ -97,8 +108,9 @@ const hardwareTools = {
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async diskInfo() {
+  async diskInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -114,7 +126,7 @@ const hardwareTools = {
         type,
         name,
         vendor,
-        diskSize: `${(size / 1073741824).toFixed(2)} GB`,
+        diskSize: `${gigabyteConvert(size)} GB`,
         interfaceType
       }));
   
@@ -123,8 +135,9 @@ const hardwareTools = {
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async controllerInfo() {
+  async controllerInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -139,7 +152,7 @@ const hardwareTools = {
         vendor,
         vramSize: vram < 1024
           ? `${vram} MB`
-          : `${(vram / 1024).toFixed(2)} GB`
+          : `${gigabyteConvert(vram, 1024)} GB`
       }));
   
       // show results
@@ -147,8 +160,9 @@ const hardwareTools = {
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async displayInfo() {
+  async displayInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -173,8 +187,9 @@ const hardwareTools = {
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   },
-  async biosInfo() {
+  async biosInfo(refreshCallback) {
     console.clear();
 
     try {
@@ -188,12 +203,13 @@ const hardwareTools = {
       console.table({
         releaseDate,
         vendor,
-        bios_revision: revision === "" ? "no info" : revision,
+        bios_revision: revision || "no info",
         version
       });
     } catch (err) {
       console.error(colors.red(err.message));
     }
+    setTimeout(refreshCallback, timeout);
   }
 };
 

package/functions/moviesInfo.js

@@ -5,10 +5,12 @@ import { printTable } from "console-table-printer";
 
 /** 
  * @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 +41,10 @@ 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);
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-// export
-export default movieDB;
+}

package/functions/multipleStack.js

@@ -1,8 +1,7 @@
 // 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";
@@ -10,30 +9,21 @@ import { listFormat } 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}) => {
+    
+    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 +37,11 @@ const multipleStack = async (urls) => {
         };
       });
 
-      console.info(colors.green(figlet.textSync(url, "Small")));
-      console.group();
       printTable(stackResult);
-      console.groupEnd();
-    });
+    }
   } catch (err) {
     console.error(colors.red(err.message));
   }
 
   await wappalyzer.destroy();
-};
-
-export default multipleStack;
+}

package/functions/pageSpeed.js

@@ -1,116 +1,72 @@
 // modules
-import { default as axios } from "axios";
-import { SingleBar } from "cli-progress";
+import { MultiBar, Presets } from "cli-progress";
 import colors from "colors";
 
+// 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();
   } catch (err) {
     console.error(colors.red(err.message));
   }
-};
-
-export default pageSpeed;
+}

package/functions/password.js

@@ -0,0 +1,20 @@
+/**
+ * It generates a random password
+ * @returns {void}
+ */
+export default function genPassword() {
+  const chars = "0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  // blank password var
+  let password = "";
+
+  // loop generate chars
+  for(let i = 0; i < 12; i++) {
+    const randomNumber = Math.floor(Math.random() * chars.length);
+
+    password += chars.substring(randomNumber, randomNumber + 1);
+  }
+
+  // print new passwors
+  console.info("new password:", password);
+}