stack-analyze 1.1.6 → 1.1.9

package/index.mjs

@@ -0,0 +1,496 @@
+// modules
+import {default as axios} from "axios";
+import CoinGecko from "coingecko-api";
+import {
+  cpu,
+  mem,
+  osInfo,
+  diskLayout,
+  graphics,
+  bios
+} from "systeminformation";
+import Wappalyzer from "wappalyzer";
+
+const animeSearch = async ({ query, results }) => {
+  /* error manager */
+  try {
+    // call api
+    const { data } = await axios.get("https://api.jikan.moe/v3/search/anime", {
+      params: {
+        q: query,
+        limit: 10
+      }
+    });
+
+    results(data.results);
+
+  } catch (err) { results(err); }
+};
+
+const bitlyInfo = async ({ link, token, results }) => {
+  try {
+    const { data } = await axios.post(
+      "https://api-ssl.bitly.com/v4/expand",
+      {
+        bitlink_id: link
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+
+    results(data);
+  } catch (err) { results(err); }
+};
+
+const cryptoMarket = async (callback) => {
+  try {
+    // start crypto
+    const { data } = await axios.get(
+      "https://api.coingecko.com/api/v3/coins/markets", {
+        params: {
+          vs_currency: "usd",
+          per_page: 10
+        }
+      }
+    );
+
+    // map coinData
+    callback(data);
+  } catch (err) { callback(err); }
+};
+
+async function githubInfo({ user, results }) {
+  try {
+    const { data } = await axios.get(`https://api.github.com/users/${user}`);
+
+    results(data);
+  } catch (err) { results(err); }
+}
+
+async function cpuInfo(callback) {
+  try {
+    const {
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    } = await cpu();
+
+    // show results
+    callback({
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    });
+  } catch (err) { callback(err); }
+}
+
+async function ramMemInfo(callback) {
+  try {
+    const {
+      total,
+      free,
+      used,
+      active,
+      available
+    } = await mem();
+
+    // show results
+    callback({
+      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) { callback(err); }
+}
+
+async function osDetail(callback) {
+  try {
+    const {
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    } = await osInfo();
+
+    // show results
+    callback({
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    });
+  } catch (err) { callback(err); }
+}
+
+async function diskInfo(callback) {
+  try {
+    const disks = await diskLayout();
+
+    const disksList = disks.map(({
+      type,
+      name,
+      vendor,
+      size,
+      interfaceType
+    }) => ({
+      type,
+      name,
+      vendor,
+      diskSize: `${(size / 1073741824).toFixed(2)} GB`,
+      interfaceType
+    }));
+
+    callback(disksList);
+
+  } catch (err) { callback(err); }
+}
+
+async function controllerInfo(callback) {
+  try {
+    const { controllers } = await graphics();
+
+    const controllersList = controllers.map(({
+      model,
+      vendor,
+      vram
+    }) => ({
+      model,
+      vendor,
+      vramSize: vram < 1024
+        ? `${vram} MB`
+        : `${(vram / 1024).toFixed(2)} GB`
+    }));
+
+    callback(controllersList);
+  } catch (err) { callback(err); }
+}
+
+async function displayInfo(callback) {
+  try {
+    const { displays } = await graphics();
+
+    const displayList = displays.map(({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }) => ({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }));
+
+    callback(displayList);
+  } catch (err) { callback(err); }
+}
+
+async function biosInfo(callback) {
+  try {
+    const {
+      releaseDate,
+      vendor,
+      revision,
+      version
+    } = await bios();
+
+    callback({ releaseDate, vendor, revision, version });
+  } catch (err) { callback(err); }
+}
+
+const movieDB = async ({ api_key, query, results }) => {
+  try {
+    const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
+      params: {
+        api_key,
+        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 !== "");
+
+    results(movieData);
+  } catch (err) { results(err); }
+};
+
+async function multipleStack({ urls, results }) {
+  let result;
+  const wappalyzer = new Wappalyzer();
+  try {
+    await wappalyzer.init();
+    result = await Promise.all(
+      urls.map(async (url) => {
+        const { technologies } = await wappalyzer.open(url).analyze();
+        return {
+          url,
+          technologies
+        };
+      })
+    );
+  } catch (err) { result = err; }
+  await wappalyzer.destroy();
+  results(result);
+}
+
+const pageSpeed = async ({ url, results }) => {
+  try {
+    const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+      params: {
+        url,
+        key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+        strategy: "mobile"
+      }
+    });
+
+    const resDesktop = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+      params: {
+        url,
+        key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+        strategy: "desktop"
+      }
+    });
+
+    // extract results
+    const mobile = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
+    const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
+
+    results({ mobile, desktop });
+  } catch (err) { results(err); }
+};
+
+async function singleStack({ url, results }) {
+  const wappalyzer = await new Wappalyzer;
+
+  let result;
+  try {
+    await wappalyzer.init();
+
+    const { technologies } = await wappalyzer.open(url).analyze();
+
+    result = technologies.map(({
+      name,
+      website,
+      categories
+    }) => ({
+      techName: name,
+      techWebsite: website,
+      techCategories: categories.map(({ name }) => name).join(", ")
+    }));
+  } catch (err) { results(err); }
+
+  await wappalyzer.destroy();
+  results(result);
+}
+
+async function twitchInfo({ query, token, clientID, results }) {
+  try {
+    const { data: twitchData } = await axios.get(`https://api.twitch.tv/helix/users?login=${query}`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Client-Id": clientID
+        }
+      });
+
+    results(twitchData.data);
+  } catch (err) { results(err); }
+}
+
+function scrape(url) {
+  let $;
+
+  const scraping = axios.create({
+    baseURL: url
+  });
+
+  const title = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      callback($("title").text());
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const images = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const imgs = $("img").map((i, el) => ({
+        imagePath: $(el).attr("src"),
+        imageTitle: $(el).attr("alt")
+      })).toArray();
+
+      callback(imgs);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const metadata = async (callback) => {
+    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);
+
+      callback(metadataList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const headings = async (callback) => {
+    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();
+
+      callback(headingList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_heading = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableHeadList = $("th").map((i, el) => ({
+        headingRow: i,
+        text: $(el).text()
+      })).toArray();
+
+      callback(tableHeadList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const table_data = async (callback) => {
+    try {
+      const { data } = await scraping.get("");
+      $ = load(data);
+
+      const tableColumnList = $("td").map((i, el) => $(el).text()).toArray();
+
+      callback(tableColumnList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+
+  const links = async (callback) => {
+    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);
+
+      callback(linkList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  const cites = async (callback) => {
+    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();
+      
+      callback(citeList);
+    } catch (err) { console.error(colors.red(err.message)); }
+  };
+
+  return {
+    title,
+    images,
+    metadata,
+    headings,
+    table_heading,
+    table_data,
+    links,
+    cites
+  };
+}
+
+
+// exports
+export {
+  animeSearch,
+  bitlyInfo,
+  cryptoMarket,
+  githubInfo,
+  controllerInfo,
+  osDetail,
+  diskInfo,
+  displayInfo,
+  biosInfo,
+  cpuInfo,
+  ramMemInfo,
+  movieDB,
+  multipleStack,
+  pageSpeed,
+  singleStack,
+  twitchInfo,
+  scrape
+};

package/package.json

@@ -1,28 +1,35 @@
 {
   "name": "stack-analyze",
-  "version": "1.1.6",
+  "version": "1.1.9",
+  "type": "module",
   "description": "cli tech stack analyze and pagespeed with node.js using the wappalyzer module. with google pagespeed api, hardware and crypto market",
-  "main": "index.js",
+  "main": "index.mjs",
   "bin": {
     "stack-analyze": "cli.js"
   },
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "import": "./index.mjs"
+    }
+  },
   "dependencies": {
-    "axios": "^0.21.4",
-    "cli-progress": "^3.9.1",
-    "coingecko-api": "^1.0.10",
+    "axios": "^0.27.2",
+    "cheerio": "^1.0.0-rc.12",
+    "cli-progress": "^3.11.2",
     "colors": "^1.4.0",
-    "console-table-printer": "^2.10.0",
+    "console-table-printer": "^2.11.0",
     "figlet": "^1.5.2",
-    "inquirer": "^8.2.0",
-    "systeminformation": "^5.9.9",
+    "inquirer": "^9.0.0",
+    "systeminformation": "^5.11.22",
     "timeago.js": "^4.0.2",
-    "wappalyzer": "^6.9.2"
+    "wappalyzer": "^6.10.37"
   },
   "devDependencies": {
-    "eslint": "^7.32.0",
-    "gh-pages": "^3.2.3",
-    "jest": "^27.3.1",
-    "jsdoc": "^3.6.7",
+    "eslint": "^8.18.0",
+    "gh-pages": "^4.0.0",
+    "jest": "^28.1.2",
+    "jsdoc": "^3.6.10",
     "minami": "^1.2.3"
   },
   "scripts": {
@@ -35,7 +42,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/intermachine-developers/stack-analyze.git"
+    "url": "git+https://github.com/stack-analyze/stack-analyze.git"
   },
   "keywords": [
     "cli",
@@ -51,12 +58,12 @@
     "crypto market info",
     "movie info"
   ],
-  "author": "Intermachine Developers",
+  "author": "stack-analyze",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/intermachine-developers/stack-analyze/issues"
+    "url": "https://github.com/stack-analyze/stack-analyze/issues"
   },
-  "homepage": "https://intermachine-developers.github.io/stack-analyze/",
+  "homepage": "https://stack-analyze.github.io/stack-analyze/",
   "directories": {
     "doc": "docs",
     "test": "test"

package/readme.md

@@ -15,13 +15,21 @@ cli tech stack analyze with **node.js** using the wappalyzer and google pagespee
 use the cli program install
 
 ## example module
->npx stack-analyze "using external without install"<br>
->npm i -g stack-analyze "global install"<br>
+``` sh
+# global old npm versions
+npm i -g stack-analyze
+
+# global new module
+npm i --location=global
+
+# portable
+npx stack-analyze
+```
 >note: if global install fail using npx
 
-[github repo](https://github.com/intermachine-developers/stack-analyze.git)
+[github repo](https://github.com/stack-analyze/stack-analyze.git)
 
-[docs](https://intermachine-developers.github.io/stack-analyze)
+[docs](https://stack-analyze.github.io/stack-analyze/)
 
 [gitlab repo](https://gitlab.com/Intermachine-dev/stack-analyze)
 
@@ -29,4 +37,4 @@ use the cli program install
 - [changelog module](/CHANGELOG.md)
 ## author this project Julian David Cordoba Torres as omega5300
 
-**Intermachine Developers LICENSE MIT**
+**stack-analyze LICENSE MIT**

package/utils.js

@@ -0,0 +1,15 @@
+const listFormat = new Intl.ListFormat("en", {
+  style: "short",
+  type: "conjunction"
+});
+
+const currency = Intl.NumberFormat("en-us", {
+  style: "currency",
+  currency: "USD"
+});
+
+export {
+  listFormat,
+  currency
+};
+

package/about/index.js

@@ -1,56 +0,0 @@
-// version module
-const { license, version } = require("../package.json");
-
-/**
- * @type {{ mainDeveloper: string, version: string, license: string }}
- */
-const aboutApp = {
-  mainDeveloper: "omega5300",
-  license,
-  version
-};
-
-/**
- * @typedef {Object} ideas
- * @property {string} ideas.author
- * @property {string} ideas.tool
- */
-
-/** @type {ideas[]} */
-const ideas = [
-  { author: "verguiskarime", tool: "bitly info" }
-];
-
-/** @type { string[] } */
-const developers = [ "omega5300" ];
-
-/**
- * @typedef {Object} youtubeDev
- * @property {string} youtubeDev.youtubeChannel
- * @property {string} youtubeDev.recomendation
- */
-
-/** @type {youtubeDev[]} */
-const youtubeDev = [
-  { youtubeChannel: "fazt", recomendation: "recommend" },
-  { youtubeChannel: "doriandesings", recomendation: "recommend" },
-  { youtubeChannel: "bluuweb", recomendation: "recommend" },
-  { youtubeChannel: "leonidas esteban", recomendation: "neutral recommend" },
-  { youtubeChannel: "fernando herrera", recomendation: "recommend" },
-  { youtubeChannel: "soy dalto", recomendation: "neutral recommend" },
-];
-
-/** @type { string[] } */
-const twitch = [ "dannyaegyo" ];
-
-/** @type { string[] } */
-const projects = [ "Doofy's Projects" ];
-
-module.exports = {
-  aboutApp,
-  developers,
-  youtubeDev,
-  twitch,
-  projects,
-  ideas
-};