stack-analyze 1.1.7 → 1.2.0

package/functions/scraping.js

@@ -0,0 +1,153 @@
+import { default as axios } from "axios";
+import { load } from "cheerio";
+import colors from "colors";
+import { printTable } from "console-table-printer";
+
+/**
+ * @typedef {Object} options
+ * @property {function(): Promise<void>} options.title
+ * @property {function(): Promise<void>} options.images
+ * @property {function(): Promise<void>} options.metadata
+ * @property {function(): Promise<void>} options.headings
+ * @property {function(): Promise<void>} options.table_heading
+ * @property {function(): Promise<void>} options.table_data
+ * @property {function(): Promise<void>} options.links
+ * @property {function(): Promise<void>} options.cites
+ * 
+ * @param {string} url 
+ * @returns {options}
+ */
+export default function scrape(url) {
+  let $;
+
+  const scraping = axios.create({
+    baseURL: url
+  });
+
+  const title = async () => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      console.info("title page:", $("title").text());
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const images = async () => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const imgs = $("img").map((i, el) => ({
+        imagePath: $(el).attr("src"),
+        imageTitle: $(el).attr("alt")
+      })).toArray();
+
+      imgs.length === 0
+        ? console.info("no found images")
+        : printTable(imgs);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const metadata = async () => {
+    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);
+
+      printTable(metadataList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const headings = async () => {
+    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();
+
+      printTable(headingList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_heading = async () => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableHeadList = $("th").map((i, el) => ({
+        headingRow: i,
+        text: $(el).text()
+      })).toArray();
+
+      tableHeadList.length === 0
+        ? console.info("no found th tags")
+        : printTable(tableHeadList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_data = async () => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableColumnList = $("td").map((i, el) => $(el).text()).toArray();
+
+      tableColumnList.length === 0
+        ? console.info("no found td tags")
+        : printTable(tableColumnList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+
+  const links = async () => {
+    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);
+
+      printTable(linkList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const cites = async () => {
+    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();
+
+      citeList.length === 0
+        ? console.info("no found q and/or blockquote tags")
+        : printTable(citeList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  return {
+    title,
+    images,
+    metadata,
+    headings,
+    table_heading,
+    table_data,
+    links,
+    cites
+  };
+}

package/functions/singleStack.js

@@ -2,7 +2,10 @@
 import Wappalyzer from "wappalyzer";
 import figlet from "figlet";
 import colors from "colors";
-import stackTable from "../models/stackTables.js";
+import { printTable } from "console-table-printer";
+
+// list format
+import { listFormat } from "../utils.js";
 
 /**
  * 
@@ -23,17 +26,19 @@ export default async function singleStack(url) {
       name,
       website,
       categories
-    }) => ({
-      techName: name,
-      techWebsite: website,
-      techCategories: categories.map(({ name }) => name).join(", ")
-    }));
+    }) => {
+      const stackCategories = categories.map(({ name }) => name);
 
-    console.info(colors.green(figlet.textSync(url)));
+      return {
+        techName: name,
+        techWebsite: website,
+        techCategories: listFormat.format(stackCategories)
+      };
+    });
 
-    stackTable.addRows(stackResult);
+    console.info(colors.green(figlet.textSync(url)));
 
-    stackTable.printTable();
+    printTable(stackResult);
   } catch (err) {
     console.error(colors.red(err.message));
   }

package/functions/twitch.js

@@ -1,11 +1,10 @@
 // modules
-import "../env/twitchID.env.js";
-import axios from "axios";
+import { default as axios } from "axios";
 import { format } from "timeago.js";
 import colors from "colors";
 
 // table
-import twitchTable from "../models/twitchTables.js";
+import { printTable } from "console-table-printer";
 
 /**
  * 
@@ -14,13 +13,13 @@ import twitchTable from "../models/twitchTables.js";
  * @param {string} apiToken - twitch api token
  * @returns { Promise<void> } - return twitch results
  */
-const twitchInfo = async (twitchUser, apiToken) => {
+const twitchInfo = async (twitchUser, twitchClient, 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
+        "Client-Id": twitchClient
       }
     });
 
@@ -36,8 +35,7 @@ const twitchInfo = async (twitchUser, apiToken) => {
       createdTime: format(created_at)
     }));
 
-    twitchTable.addRows(result);
-    twitchTable.printTable();
+    printTable(result);
   } catch (err) {
     console.error(colors.red(err));
   }

package/index.cjs

@@ -1,6 +1,5 @@
 // modules
 const axios = require("axios").default;
-const CoinGecko = require("coingecko-api");
 const {
   cpu,
   mem,
@@ -10,53 +9,13 @@ const {
   bios
 } = require("systeminformation");
 const Wappalyzer = require("wappalyzer");
+const cheerio = require("cheerio");
 
-// init coingecko api
-const CoinGeckoClient = new CoinGecko();
-
-/**
- * @typedef {Object} anime
- * @property {string} anime.query
- * @property {function(data): void} anime.results
- * 
- * @typedef {Object} bitly
- * @property {string} bitly.link
- * @property {string} bitly.token
- * @property {function(data): void} bitly.results
- * 
- * @typedef {Object} github
- * @property {string} github.user
- * @property {string} github.results
- * 
- * @typedef {Object} movie
- * @property {string} movie.api_key
- * @property {string} movie.query
- * @property {function(data): void} movie.results
- * 
- * @typedef {Object} multiple
- * @property {string[]} multiple.urls
- * @property {function(data): void} multiple.results
- * 
- * @typedef {Object} stack
- * @property {string} stack.urls
- * @property {function(data): void} stack.results
- * 
- * @typedef {Object} twitch
- * @property {string} twitch.query
- * @property {string} twitch.token
- * @property {string} twitch.clientID
- * @property {function(data): void} twitch.results
- */
-
-/**
- * @param {anime} {query, results}
- * @returns {Promise<void>}
- */
-const animeSearch = async ({ query, results }) => {
+const animeSearch = async ({ query, results, failed }) => {
   /* error manager */
   try {
     // call api
-    const { data } = await axios.get("https://api.jikan.moe/v3/search/anime", {
+    const { data } = await axios.get("https://api.jikan.moe/v/anime", {
       params: {
         q: query,
         limit: 10
@@ -65,14 +24,10 @@ const animeSearch = async ({ query, results }) => {
 
     results(data.results);
 
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
 };
 
-/**
- * @param {bitly} {link, token, results}
- * @returns {Promise<void>}
- */
-const bitlyInfo = async ({ link, token, results }) => {
+const bitlyInfo = async ({ link, token, results, failed }) => {
   try {
     const { data } = await axios.post(
       "https://api-ssl.bitly.com/v4/expand",
@@ -88,45 +43,34 @@ const bitlyInfo = async ({ link, token, results }) => {
     );
 
     results(data);
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
 };
 
-/**
- *
- * @descripiton call the crypto market list
- * @param {function(data): void} callback
- * @returns { Promise<void> } - return results search
- */
-const cryptoMarket = async (callback) => {
+const cryptoMarket = async ({results, failed}) => {
   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
-    callback(coinData.data);
-  } catch (err) { callback(err); }
+    results(data);
+  } catch (err) { failed(err); }
 };
 
-/**
- *
- * @param {github} {user, results}
- * @returns {Promise<void>}
- */
-async function githubInfo({ user, results }) {
+async function githubInfo({ user, results, failed }) {
   try {
     const { data } = await axios.get(`https://api.github.com/users/${user}`);
 
     results(data);
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function cpuInfo(callback) {
   try {
     const {
@@ -156,11 +100,6 @@ async function cpuInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function ramMemInfo(callback) {
   try {
     const {
@@ -182,11 +121,6 @@ async function ramMemInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function osDetail(callback) {
   try {
     const {
@@ -214,11 +148,6 @@ async function osDetail(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function diskInfo(callback) {
   try {
     const disks = await diskLayout();
@@ -242,11 +171,6 @@ async function diskInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function controllerInfo(callback) {
   try {
     const { controllers } = await graphics();
@@ -267,11 +191,6 @@ async function controllerInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function displayInfo(callback) {
   try {
     const { displays } = await graphics();
@@ -294,11 +213,6 @@ async function displayInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- *
- * @param {function(data): void} callback
- * @returns {Promise<void>}
- */
 async function biosInfo(callback) {
   try {
     const {
@@ -312,11 +226,7 @@ async function biosInfo(callback) {
   } catch (err) { callback(err); }
 }
 
-/**
- * @param {movie} {api_key, query, results}
- * @returns {Promise<void>} void results
- */
-const movieDB = async ({ api_key, query, results }) => {
+const movieDB = async ({ api_key, query, results, failed }) => {
   try {
     const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
       params: {
@@ -350,14 +260,10 @@ const movieDB = async ({ api_key, query, results }) => {
       .filter(({ release_date }) => release_date !== undefined && release_date !== "");
 
     results(movieData);
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
 };
 
-/**
- * @param {multiple} {urls, results}
- * @returns {Promise<void>}
- */
-async function multipleStack({ urls, results }) {
+async function multipleStack({ urls, results, failed }) {
   let result;
   const wappalyzer = new Wappalyzer();
   try {
@@ -371,16 +277,12 @@ async function multipleStack({ urls, results }) {
         };
       })
     );
-  } catch (err) { result = err; }
+    results(result);
+  } catch (err) { failed(err); }
   await wappalyzer.destroy();
-  results(result);
 }
 
-/**
- * @param {stack} {url, results}
- * @returns {Promise<void>}
- */
-const pageSpeed = async ({ url, results }) => {
+const pageSpeed = async ({ url, results, failed }) => {
   try {
     const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
       params: {
@@ -403,14 +305,10 @@ const pageSpeed = async ({ url, results }) => {
     const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
 
     results({ mobile, desktop });
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
 };
 
-/**
- * @param {stack} {url, results}
- * @returns {Promise<void>}
- */
-async function singleStack({ url, results }) {
+async function singleStack({ url, results, failed }) {
   const wappalyzer = await new Wappalyzer;
 
   let result;
@@ -428,18 +326,13 @@ async function singleStack({ url, results }) {
       techWebsite: website,
       techCategories: categories.map(({ name }) => name).join(", ")
     }));
-  } catch (err) { results(err); }
+    results(result);
+  } catch (err) { failed(err); }
 
   await wappalyzer.destroy();
-  results(result);
 }
 
-/**
- *
- * @param {twitch} { query, token, clientID, results }
- * @returns {Promise<void>}
- */
-async function twitchInfo({ query, token, clientID, results }) {
+async function twitchInfo({ query, token, clientID, results, failed }) {
   try {
     const { data: twitchData } = await axios.get(`https://api.twitch.tv/helix/users?login=${query}`,
       {
@@ -450,9 +343,152 @@ async function twitchInfo({ query, token, clientID, results }) {
       });
 
     results(twitchData.data);
-  } catch (err) { results(err); }
+  } catch (err) { failed(err); }
+}
+
+function scrape(url) {
+  let $;
+
+  const scraping = axios.create({
+    baseURL: url
+  });
+
+  const title = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      results($("title").text());
+    } catch (err) { failed(err); }
+  };
+
+  const images = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const imgs = $("img").map((i, el) => ({
+        imagePath: $(el).attr("src"),
+        imageTitle: $(el).attr("alt")
+      })).toArray();
+
+      results(imgs);
+    } catch (err) { failed(err); }
+  };
+
+  const metadata = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const metadataList = $("meta").map((i, el) => ({
+        metaInfo: $(el).attr("name"),
+        metaContent: $(el).attr("content")
+      })).toArray()
+        .filter(({ metaInfo }) => metaInfo !== undefined);
+
+      results(metadataList);
+    } catch (err) { failed(err); }
+  };
+
+  const headings = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const headingList = $("h1, h2, h3, h4, h5, h6").map((i, el) => ({
+        headingTag: $(el).prop("tagName"),
+        headingText: $(el).text()
+      })).toArray();
+
+      results(headingList);
+    } catch (err) { failed(err); }
+  };
+
+  const table_heading = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const tableHeadList = $("th").map((i, el) => ({
+        headingRow: i,
+        text: $(el).text()
+      })).toArray();
+
+      results(tableHeadList);
+    } catch (err) { failed(err); }
+  };
+
+  const table_data = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const tableColumnList = $("td").map((i, el) => $(el).text()).toArray();
+
+      results(tableColumnList);
+    } catch (err) { failed(err); }
+  };
+
+
+  const links = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const linkList = $("a").map((i, el) => ({
+        url: $(el).attr("href"),
+        text: $(el).text()
+      })).toArray()
+        .filter(({ url }) => url.indexOf("#") !== 0);
+
+      results(linkList);
+    } catch (err) { failed(err); }
+  };
+
+  const cites = async ({results, failed}) => {
+    try {
+      const { data } = await scraping.get(url);
+      $ = cheerio.load(data);
+
+      const citeList = $("q, blockquote").map((i, el) => ({
+        citeTag: $(el).prop("tagName"),
+        citeLink: $(el).attr("cite"),
+        citeText: $(el).text()
+      })).toArray();
+      
+      results(citeList);
+    } catch (err) { failed(err); }
+  };
+
+  return {
+    title,
+    images,
+    metadata,
+    headings,
+    table_heading,
+    table_data,
+    links,
+    cites
+  };
 }
 
+const password = () => {
+  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);
+  }
+
+  return password;
+};
+
 // exports
 module.exports = {
   animeSearch,
@@ -470,5 +506,7 @@ module.exports = {
   multipleStack,
   pageSpeed,
   singleStack,
-  twitchInfo
+  twitchInfo,
+  scrape,
+  password
 };