stack-analyze 1.1.4 → 1.1.7

package/index.mjs

@@ -0,0 +1,474 @@
+// modules
+import axios from "axios";
+import CoinGecko from "coingecko-api";
+import {
+  cpu,
+  mem,
+  osInfo,
+  diskLayout,
+  graphics,
+  bios
+} from "systeminformation";
+import Wappalyzer from "wappalyzer";
+
+// 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 }) => {
+  /* 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); }
+};
+
+/**
+ * @param {bitly} {link, token, results}
+ * @returns {Promise<void>}
+ */
+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); }
+};
+
+/**
+ *
+ * @descripiton call the crypto market list
+ * @param {function(data): void} callback
+ * @returns { Promise<void> } - return results search
+ */
+const cryptoMarket = async (callback) => {
+  try {
+    // start crypto
+    const coinData = await CoinGeckoClient.coins.markets({
+      per_page: 10
+    });
+
+    // map coinData
+    callback(coinData.data);
+  } catch (err) { callback(err); }
+};
+
+/**
+ *
+ * @param {github} {user, results}
+ * @returns {Promise<void>}
+ */
+async function githubInfo({ user, results }) {
+  try {
+    const { data } = await axios.get(`https://api.github.com/users/${user}`);
+
+    results(data);
+  } catch (err) { results(err); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+/**
+ *
+ * @param {function(data): void} callback
+ * @returns {Promise<void>}
+ */
+async function biosInfo(callback) {
+  try {
+    const {
+      releaseDate,
+      vendor,
+      revision,
+      version
+    } = await bios();
+
+    callback({ releaseDate, vendor, revision, version });
+  } catch (err) { callback(err); }
+}
+
+/**
+ * @param {movie} {api_key, query, results}
+ * @returns {Promise<void>} void results
+ */
+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); }
+};
+
+/**
+ * @param {multiple} {urls, results}
+ * @returns {Promise<void>}
+ */
+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);
+}
+
+/**
+ * @param {stack} {url, results}
+ * @returns {Promise<void>}
+ */
+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); }
+};
+
+/**
+ * @param {stack} {url, results}
+ * @returns {Promise<void>}
+ */
+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);
+}
+
+/**
+ *
+ * @param {twitch} { query, token, clientID, results }
+ * @returns {Promise<void>}
+ */
+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); }
+}
+
+// exports
+export {
+  animeSearch,
+  bitlyInfo,
+  cryptoMarket,
+  githubInfo,
+  controllerInfo,
+  osDetail,
+  diskInfo,
+  displayInfo,
+  biosInfo,
+  cpuInfo,
+  ramMemInfo,
+  movieDB,
+  multipleStack,
+  pageSpeed,
+  singleStack,
+  twitchInfo
+};

package/models/aboutTables.js

@@ -0,0 +1,40 @@
+// table model module
+import { Table } from "console-table-printer";
+
+// youtube model
+const youtubeDevTable = new Table({
+  columns: [
+    {
+      name: "youtubeChannel",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "recomendation",
+      alignment: "left",
+      color: "cyan"
+    }
+  ]
+});
+
+// ideas model
+const ideasTable = new Table({
+  columns: [
+    {
+      name: "author",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "tool",
+      alignment: "left",
+      color: "green"
+    }
+  ]
+});
+
+// exports tables
+export {
+  youtubeDevTable,
+  ideasTable
+};

package/models/animeTable.js

@@ -0,0 +1,33 @@
+import { Table } from "console-table-printer";
+
+const animeList = new Table({
+  columns: [
+    {
+      name: "title",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "type",
+      alignment: "left",
+      color: "magenta"
+    },
+    {
+      name: "episodes",
+      alignment: "left",
+      color: "magenta"
+    },
+    {
+      name: "debutDate",
+      alignment: "left",
+      color: "magenta"
+    },
+    {
+      name: "finalDate",
+      alignment: "left",
+      color: "green"
+    }
+  ]
+});
+
+export default animeList;

package/models/cryptoTables.js

@@ -0,0 +1,32 @@
+import { Table } from "console-table-printer";
+
+const coinTable = new Table({
+  columns: [
+    {
+      name: "symbol",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "name",
+      alignment: "left",
+      color: "white_bold"
+    },
+    {
+      name: "price",
+      alignment: "left",
+      color: "yellow"
+    },
+    {
+      name: "priceChanged",
+      alignment: "left"
+    },
+    {
+      name: "lastUpdated",
+      alignment: "left",
+      color: "magenta"
+    }
+  ]
+});
+
+export default coinTable;

package/models/hardwareTables.js

@@ -0,0 +1,87 @@
+import { Table } from "console-table-printer";
+
+const diskTables = new Table({
+  columns: [
+    {
+      name: "type",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "name",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "vendor",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "diskSize",
+      alignment: "left",
+      color: "yellow"
+    },
+    {
+      name: "interfaceType",
+      alignment: "left",
+      color: "yellow"
+    }
+  ]
+});
+
+const controllersTable = new Table({
+  columns: [
+    {
+      name: "model",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "vendor",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "vramSize",
+      alignment: "left",
+      color: "yellow"
+    }
+  ]
+});
+
+const displayTables = new Table({
+  columns: [
+    {
+      name: "model",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "main",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "connection",
+      alignment: "left",
+      color: "cyan"
+    },
+    {
+      name: "resolutionX",
+      alignment: "left",
+      color: "yellow"
+    },
+    {
+      name: "resolutionY",
+      alignment: "left",
+      color: "yellow"
+    }
+  ]
+});
+
+export {
+  diskTables,
+  controllersTable,
+  displayTables
+};

package/models/movieTables.js

@@ -0,0 +1,33 @@
+import { Table } from "console-table-printer";
+
+const movieList = new Table({
+  columns: [
+    {
+      name: "title",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "original_language",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "popularity",
+      alignment: "left",
+      color: "yellow"
+    },
+    {
+      name: "vote_average",
+      alignment: "left",
+      color: "yellow"
+    },
+    {
+      name: "release_date",
+      alignment: "left",
+      color: "yellow"
+    }
+  ]
+});
+
+export default movieList;

package/models/stackTables.js

@@ -0,0 +1,23 @@
+import { Table } from "console-table-printer";
+
+const stackTable = new Table({
+  columns: [
+    {
+      name: "techName",
+      alignment: "left",
+      color: "cyan"
+    },
+    {
+      name: "techWebsite",
+      alignment: "left",
+      color: "green"
+    },
+    {
+      name: "techCategories",
+      alignment: "left",
+      color: "cyan"
+    }
+  ]
+});
+
+export default stackTable;