@bigbinary/neeto-commons-frontend 3.0.6 → 3.0.9

package/cjs/configs/nextjs/eslint/imports/order.js

@@ -0,0 +1,25 @@
+const { assocPath } = require("ramda");
+
+const {
+  buildPathGroupsBasedOnWebpackAliases,
+} = require("../../../eslint/helpers");
+const commonConfig = require("../../../eslint/imports/order");
+
+const pathGroups = buildPathGroupsBasedOnWebpackAliases({
+  customAliasPath: "resolve.js",
+  commonAliasPath:
+    "node_modules/@bigbinary/neeto-commons-frontend/configs/nextjs/webpack/resolve.js",
+});
+
+const pathGroupForKeepingReactImportsAtTop = {
+  pattern: "react+(-native|)",
+  group: "external",
+  position: "before",
+};
+pathGroups.push(pathGroupForKeepingReactImportsAtTop);
+
+module.exports = assocPath(
+  ["rules", "import/order", 1, "pathGroups"],
+  pathGroups,
+  commonConfig
+);

package/cjs/configs/nextjs/eslint/index.js

@@ -0,0 +1,22 @@
+const { mergeLeft } = require("ramda");
+
+const commonConfiguration = require("../../eslint");
+
+const nextjsConfiguration = {
+  extends: [
+    "plugin:@bigbinary/neeto/nextjs-recommended",
+    "plugin:cypress/recommended",
+    "plugin:json/recommended",
+    "eslint:recommended",
+    "plugin:react/recommended",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/globals",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/nextjs/eslint/imports/order",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/overrides",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/imports/enforced",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/react",
+    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/promise",
+    "prettier",
+  ],
+};
+
+module.exports = mergeLeft(nextjsConfiguration, commonConfiguration);

package/cjs/configs/nextjs/webpack/resolve.js

@@ -0,0 +1 @@
+module.exports = {};

package/cjs/configs/prettier.js

@@ -0,0 +1,16 @@
+module.exports = {
+  tailwindConfig: "./tailwind.config.js",
+  trailingComma: "es5",
+  arrowParens: "avoid",
+  printWidth: 80,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  quoteProps: "as-needed",
+  jsxSingleQuote: false,
+  singleQuote: false,
+  bracketSpacing: true,
+  bracketSameLine: false,
+  proseWrap: "always",
+  endOfLine: "lf",
+};

package/cjs/configs/scripts/dead-code-eliminator/constants.js

@@ -0,0 +1,12 @@
+const RAILS_MOUNTED_COMPONENTS_REGEX = /app\/javascript\/src\/[^/]*\.(js|jsx)$/;
+const PACKS_FILES_REGEX = /app\/javascript\/packs\/[^/]*\.(js|jsx)$/;
+
+const TYPES = {
+  CLASS_DECLARATION: "ClassDeclaration",
+  FUNCTION_DECLARATION: "FunctionDeclaration",
+  IMPORT_DEFAULT_SPECIFIER: "ImportDefaultSpecifier",
+  IMPORT_NAMESPACE_SPECIFIER: "ImportNamespaceSpecifier",
+  VARIABLE_DECLARATION: "VariableDeclaration",
+};
+
+module.exports = { RAILS_MOUNTED_COMPONENTS_REGEX, PACKS_FILES_REGEX, TYPES };

package/cjs/configs/scripts/dead-code-eliminator/index.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+const { exec, execSync } = require("child_process");
+const fs = require("fs");
+const pathLib = require("path");
+
+const generate = require("@babel/generator").default;
+const babelParser = require("@babel/parser");
+const traverse = require("@babel/traverse").default;
+const { isNotEmpty, existsBy } = require("@bigbinary/neeto-cist");
+const enhancedResolve = require("enhanced-resolve");
+const { isEmpty, includes, __ } = require("ramda");
+
+const {
+  RAILS_MOUNTED_COMPONENTS_REGEX,
+  TYPES,
+  PACKS_FILES_REGEX,
+} = require("./constants");
+
+// @ts-ignore
+// eslint-disable-next-line import/extensions
+const webpackConfig = require("../../../../../../config/webpack/webpack.config.js");
+
+let modifiedFiles = [];
+let importedItems = [];
+let unusedFiles = [];
+let iterationCount = 1;
+
+const javascriptDir = pathLib.resolve(
+  __dirname,
+  "../../../../../../app/javascript"
+);
+
+const resolver = enhancedResolve.create.sync({
+  alias: webpackConfig.resolve.alias,
+  modules: webpackConfig.resolve.modules,
+  extensions: webpackConfig.resolve.extensions,
+  fallback: webpackConfig.resolve.fallback,
+  conditionNames: ["require", "import", "node", "default", "types"],
+});
+
+const isRailsMountedOrPacksFiles = filePath =>
+  RAILS_MOUNTED_COMPONENTS_REGEX.test(filePath) ||
+  PACKS_FILES_REGEX.test(filePath);
+
+const isInImportedList = (item, filePath) =>
+  existsBy({ item: includes(__, [item, "*"]), filePath }, importedItems);
+
+const findImports = filePath => {
+  const code = fs.readFileSync(filePath, "utf8");
+  const ast = babelParser.parse(code, {
+    sourceType: "module",
+    plugins: ["jsx"],
+  });
+
+  traverse(ast, {
+    ImportDeclaration(path) {
+      const { node } = path;
+
+      const currentDir = pathLib.dirname(filePath);
+      const importSource = node.source.value;
+
+      const resolvedPath = resolver(currentDir, importSource);
+      const isNodeModule = resolvedPath.includes("node_modules");
+      if (isNodeModule) return;
+
+      if (isEmpty(node.specifiers)) {
+        importedItems.push({ item: "*", filePath: resolvedPath });
+      }
+
+      node.specifiers.forEach(specifier => {
+        if (specifier.type === TYPES.IMPORT_NAMESPACE_SPECIFIER) {
+          importedItems.push({ item: "*", filePath: resolvedPath });
+        } else if (specifier.type === TYPES.IMPORT_DEFAULT_SPECIFIER) {
+          importedItems.push({ item: "default", filePath: resolvedPath });
+        } else {
+          const item = specifier.imported.name;
+          importedItems.push({ item, filePath: resolvedPath });
+        }
+      });
+    },
+  });
+};
+
+const removeUnusedExports = filePath => {
+  if (isRailsMountedOrPacksFiles(filePath)) return;
+
+  if (!existsBy({ filePath }, importedItems)) {
+    unusedFiles.push(filePath);
+
+    return;
+  }
+
+  let isPathModified = false;
+  const code = fs.readFileSync(filePath, "utf8");
+  const ast = babelParser.parse(code, {
+    sourceType: "module",
+    plugins: ["jsx"],
+  });
+
+  traverse(ast, {
+    ExportNamedDeclaration(path) {
+      const { node } = path;
+      if (node.declaration) {
+        if (node.declaration.type === TYPES.VARIABLE_DECLARATION) {
+          node.declaration.declarations.forEach(declaration => {
+            const exportedItem = declaration.id.name;
+            if (isInImportedList(exportedItem, filePath)) return;
+
+            path.replaceWith(path.node.declaration);
+            isPathModified = true;
+          });
+        } else if (
+          node.declaration.type === TYPES.FUNCTION_DECLARATION ||
+          node.declaration.type === TYPES.CLASS_DECLARATION
+        ) {
+          const exportedItem = node.declaration.id.name;
+          if (isInImportedList(exportedItem, filePath)) return;
+
+          path.replaceWith(path.node.declaration);
+          isPathModified = true;
+        }
+      } else {
+        path.get("specifiers").forEach(specifierPath => {
+          const exportedItem = specifierPath.node.exported.name;
+          if (isInImportedList(exportedItem, filePath)) return;
+
+          node.specifiers.length === 1 ? path.remove() : specifierPath.remove();
+          isPathModified = true;
+        });
+      }
+    },
+    ExportDefaultDeclaration(path) {
+      const exportedItem = "default";
+      if (isInImportedList(exportedItem, filePath)) return;
+
+      path.remove();
+      isPathModified = true;
+    },
+  });
+
+  if (!isPathModified) return;
+
+  const newCode = generate(ast, {
+    retainLines: true,
+    retainFunctionParens: true,
+  }).code;
+
+  fs.writeFileSync(filePath, newCode);
+  modifiedFiles.push(filePath);
+};
+
+const traverseDirectoryAndExecuteFunc = (dir, func) => {
+  const files = fs.readdirSync(dir);
+
+  files.forEach(file => {
+    const filePath = pathLib.join(dir, file);
+    const stats = fs.statSync(filePath);
+
+    if (stats.isFile() && [".js", ".jsx"].includes(pathLib.extname(filePath))) {
+      func(filePath);
+    } else if (stats.isDirectory()) {
+      traverseDirectoryAndExecuteFunc(filePath, func);
+    }
+  });
+};
+
+const runLintersAndRemoveUnusedFiles = () => {
+  const commands = [];
+
+  if (isNotEmpty(unusedFiles)) commands.push(`rm -f ${unusedFiles.join(" ")}`);
+
+  if (isNotEmpty(modifiedFiles)) {
+    commands.push(`npx prettier --write ${modifiedFiles.join(" ")}`);
+    commands.push(`npx eslint --fix ${modifiedFiles.join(" ")}`);
+  }
+
+  // script will be executed recursively until we have no modified files or unused files
+  exec(commands.join(" && "), () => run());
+};
+
+const restoreEslintNeetoVersion = () => {
+  execSync("git restore package.json yarn.lock", { stdio: "ignore" });
+  execSync("yarn", { stdio: "ignore" });
+};
+
+const reportNonFixableEslintErrors = () => {
+  const modifiedFiles = execSync("git diff --name-only --diff-filter=M")
+    .toString()
+    .split("\n")
+    .join(" ");
+
+  if (!modifiedFiles) {
+    console.log("✅  Script executed successfully!\n");
+
+    return;
+  }
+
+  exec(`npx eslint ${modifiedFiles} --fix --quiet`, (_, stdout) => {
+    if (stdout) {
+      console.log(stdout);
+      console.log(
+        "⭕️ Auto-fixing is not implemented for the above eslint errors. Please fix them manually.\n"
+      );
+    } else {
+      console.log("- No errors found.\n\n✅  Script executed successfully!\n");
+    }
+  });
+};
+
+const postExecution = () => {
+  console.log("\n4. Restoring @bigbinary/eslint-plugin-neeto version.");
+  restoreEslintNeetoVersion();
+
+  console.log("\n5. Checking if there are any non-fixable eslint errors.");
+  reportNonFixableEslintErrors();
+};
+
+const installCustomEslintNeetoVersion = () =>
+  execSync(
+    "yarn add @bigbinary/eslint-plugin-neeto@1.0.43-no-unused-vars-autofix",
+    { stdio: "ignore" }
+  );
+
+const run = () => {
+  console.log(`\nIteration: ${iterationCount++}`);
+  console.log(".............");
+
+  modifiedFiles = [];
+  importedItems = [];
+  unusedFiles = [];
+
+  console.log("* Collecting all the imports.");
+  traverseDirectoryAndExecuteFunc(javascriptDir, findImports);
+
+  console.log("* Removing exports which are not imported.");
+  traverseDirectoryAndExecuteFunc(javascriptDir, removeUnusedExports);
+
+  const filesCountMsg = `\nModified files: ${modifiedFiles.length}\nUnused files: ${unusedFiles.length}`;
+
+  const isExecutionCompleted = isEmpty(modifiedFiles) && isEmpty(unusedFiles);
+  if (isExecutionCompleted) {
+    console.log(filesCountMsg);
+    postExecution();
+  } else {
+    console.log(
+      "* Running linters on modified files and removing unused files."
+    );
+    runLintersAndRemoveUnusedFiles();
+    console.log(filesCountMsg);
+  }
+};
+
+// Script execution starts here
+console.log("\nPlease wait, this may take a few minutes...");
+
+console.log(
+  "\n1. Installing @bigbinary/eslint-plugin-neeto custom release required for this script."
+);
+installCustomEslintNeetoVersion();
+
+console.log(
+  "\n2. Executing script recursively until we have no modified or unused files."
+);
+run();

package/cjs/configs/scripts/getPkgTranslations.js

@@ -0,0 +1,45 @@
+const fs = require("fs");
+const path = require("path");
+
+const { mergeDeepLeft } = require("ramda");
+
+const packageDir = path.join(__dirname, "../../");
+
+const getPkgTransPath = pkg => {
+  const basePath = path.join(packageDir, pkg);
+
+  const transPath1 = path.join(basePath, "app/javascript/src/translations");
+  const transPath2 = path.join(basePath, "src/translations");
+
+  return fs.existsSync(transPath1) ? transPath1 : transPath2;
+};
+
+const packages = fs.readdirSync(packageDir);
+
+const loadTranslations = translationsDir => {
+  try {
+    const jsonFiles = fs
+      .readdirSync(translationsDir)
+      .filter(file => file.endsWith(".json"))
+      .map(file => path.join(translationsDir, file));
+
+    const translations = {};
+
+    jsonFiles.forEach(jsonFile => {
+      const content = fs.readFileSync(jsonFile, "utf8");
+      const basename = path.basename(jsonFile, ".json");
+
+      translations[basename] = { translation: JSON.parse(content) };
+    });
+
+    return translations;
+  } catch {
+    return {};
+  }
+};
+
+const packageTranslations = packages
+  .map(pkg => loadTranslations(getPkgTransPath(pkg)))
+  .reduce(mergeDeepLeft);
+
+module.exports = packageTranslations;

package/cjs/configs/scripts/jsdoc-builder/constants.mjs

@@ -0,0 +1,42 @@
+/* eslint-disable @bigbinary/neeto/no-dangling-constants */
+import { complement, startsWith } from "ramda";
+
+export const REMARK_NODE_TYPES = {
+  HTML: "html",
+  PARAGRAPH: "paragraph",
+  CODE: "code",
+  HEADING: "heading",
+  TEXT: "text",
+  INLINE_CODE: "inlineCode",
+};
+
+export const BABEL_NODE_TYPES = { IDENTIFIER: "Identifier" };
+
+export const SUBHEADING_PATTERN = { type: REMARK_NODE_TYPES.HEADING, depth: 2 };
+export const HTML_PATTERN = { type: REMARK_NODE_TYPES.HTML };
+export const IMG_PATTERN = {
+  type: REMARK_NODE_TYPES.HTML,
+  value: startsWith("<img"),
+};
+export const CODE_PATTERN = { type: REMARK_NODE_TYPES.CODE };
+export const PARAGRAPH_PATTERN = { type: REMARK_NODE_TYPES.PARAGRAPH };
+export const HTML_EXCEPT_IMG_PATTERN = {
+  type: REMARK_NODE_TYPES.HTML,
+  value: complement(startsWith("<img")),
+};
+export const INLINE_CODE_PATTERN = { type: REMARK_NODE_TYPES.INLINE_CODE };
+export const TEXT_PATTERN = { type: REMARK_NODE_TYPES.TEXT };
+export const DOCS_FOLDER_NAME = "docs";
+export const TYPES_FOLDER_NAME = "typeTemplates";
+export const EXPORTED_TYPES_FOLDER_NAME = "dist"; // root
+
+export const JSDOC_IMG_HEIGHT = "200";
+export const JSDOC_IMG_WIDTH = "300";
+
+export const DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT = "\n *\n";
+export const LINE_BREAK = "\n";
+export const JSDOC_EXAMPLE_TAG = "@example ";
+export const JSDOC_END_EXAMPLE_TAG = "@endexample";
+export const ASTERISK = "*";
+export const ASTERISK_WITH_SPACES = " * ";
+export const WHITESPACE_PARENTHESIS_REGEX = /[\s()]/g;

package/cjs/configs/scripts/jsdoc-builder/index.mjs

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+
+import _generate from "@babel/generator";
+import _traverse from "@babel/traverse";
+import * as babelTypes from "@babel/types";
+
+import {
+  DOCS_FOLDER_NAME,
+  EXPORTED_TYPES_FOLDER_NAME,
+  TYPES_FOLDER_NAME,
+} from "./constants.mjs";
+import {
+  buildEntityTitleToEntityDescMap,
+  getFileContent,
+  getFileNameList,
+  parseMarkdown,
+  parseTypeFile,
+  syncTypeFiles,
+  defaultTypeFileTraverser,
+} from "./utils.mjs";
+
+const traverse = _traverse.default;
+const generate = _generate.default;
+
+const buildJsdoc = ({
+  customTypeFileTraverser = defaultTypeFileTraverser,
+  exportedTypesFolderName = EXPORTED_TYPES_FOLDER_NAME,
+} = {}) => {
+  const fileNamesInsideDocs = getFileNameList(path.resolve(DOCS_FOLDER_NAME));
+  const typeFileNames = fs.readdirSync(path.resolve(TYPES_FOLDER_NAME));
+
+  syncTypeFiles(exportedTypesFolderName);
+
+  const entityTitleToDescMapOfAllFiles = {};
+
+  fileNamesInsideDocs.forEach(docFileName => {
+    const fileContent = getFileContent(docFileName);
+    const markdownAST = parseMarkdown(fileContent);
+
+    buildEntityTitleToEntityDescMap(
+      markdownAST.children,
+      entityTitleToDescMapOfAllFiles
+    );
+  });
+
+  // eslint-disable-next-line consistent-return
+  typeFileNames.forEach(typeFileName => {
+    const typeFileContent = getFileContent(
+      path.join(exportedTypesFolderName, typeFileName)
+    );
+    const typeFileAST = parseTypeFile(typeFileContent);
+
+    customTypeFileTraverser({
+      typeFileName: `${exportedTypesFolderName}/${typeFileName}`,
+      typeFileAST,
+      entityTitleToDescMapOfAllFiles,
+      babelTraverse: traverse,
+      babelCodeGenerator: generate,
+      babelTypes,
+    });
+  });
+
+  console.log("Successfully added JSDoc comments to type files.");
+};
+
+export default buildJsdoc;