@bigbinary/neeto-commons-frontend 4.14.0-beta.0 → 4.14.1

package/configs/eslint/react.mjs

@@ -0,0 +1,94 @@
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    rules: {
+      // not-auto-fixable: Prevent missing props validation in a React component definition.
+      "react/prop-types": "off",
+      // not-auto-fixable: Detect unescaped HTML entities, which might represent malformed tags.
+      "react/no-unescaped-entities": "off",
+      // not-auto-fixable: Prevent missing displayName in a React component definition. Useful when using React extensions in browser and checking for component name.
+      "react/display-name": "error",
+      // not-auto-fixable: Reports when this.state is accessed within setState.
+      "react/no-access-state-in-setstate": "error",
+      // not-auto-fixable: Prevent usage of dangerous JSX props. Currently jam3 plugin will take care of handling this.
+      "react/no-danger": "off",
+      // not-auto-fixable: Report when a DOM element is using both children and dangerouslySetInnerHTML.
+      "react/no-danger-with-children": "warn",
+      // not-auto-fixable: Prevent definitions of unused prop types.
+      "react/no-unused-prop-types": "error",
+      // not-auto-fixable: Report missing key props in iterators/collection literals. Important rule!
+      "react/jsx-key": ["error", { checkFragmentShorthand: true }],
+      // not-auto-fixable: Enforce no duplicate props.
+      "react/jsx-no-duplicate-props": "error",
+      // not-auto-fixable: Disallow undeclared variables in JSX.
+      "react/jsx-no-undef": "error",
+      // not-auto-fixable: Enforce PascalCase for user-defined JSX components.
+      "react/jsx-pascal-case": ["error", { allowNamespace: true }],
+      // not-auto-fixable: Prevent variables used in JSX to be marked as unused.
+      "react/jsx-uses-vars": "error",
+      // not-auto-fixable: Ensures https://reactjs.org/docs/hooks-rules.html.
+      "react-hooks/rules-of-hooks": "error",
+      // not-auto-fixable: Ensures https://reactjs.org/docs/hooks-rules.html - Checks effect dependencies.
+      "react-hooks/exhaustive-deps": "warn",
+      // auto-fixable: A fragment is redundant if it contains only one child, or if it is the child of a html element, and is not a keyed fragment.
+      "react/jsx-no-useless-fragment": ["error", { allowExpressions: true }],
+      // auto-fixable: Prefer arrow function expressions for component declaration.
+      "react/function-component-definition": [
+        "error",
+        {
+          namedComponents: "arrow-function",
+          unnamedComponents: "arrow-function",
+        },
+      ],
+      // auto-fixable: Components without children can be self-closed to avoid unnecessary extra closing tag.
+      "react/self-closing-comp": ["error", { component: true, html: true }],
+      // auto-fixable: Wrapping multiline JSX in parentheses can improve readability and/or convenience.
+      "react/jsx-wrap-multilines": [
+        "error",
+        {
+          declaration: "parens-new-line",
+          assignment: "parens-new-line",
+          return: "parens-new-line",
+          arrow: "parens-new-line",
+          condition: "parens-new-line",
+          logical: "parens-new-line",
+          prop: "ignore",
+        },
+      ],
+      // not-auto-fixable: Make sure files containing JSX is having .jsx extension.
+      "react/jsx-filename-extension": ["error", { allow: "as-needed" }],
+      // auto-fixable: Omit mentioning the "true" value if it can be implicitly understood in props.
+      "react/jsx-boolean-value": "error",
+      // auto-fixable: Partially fixable. Make sure the state and setter have symmertic naming.
+      "react/hook-use-state": "error",
+      // auto-fixable: Shorthand notations should always be at the top and also enforce props alphabetical sorting.
+      "react/jsx-sort-props": [
+        "error",
+        {
+          callbacksLast: true,
+          shorthandFirst: true,
+          multiline: "last",
+          reservedFirst: false,
+          locale: "auto",
+        },
+      ],
+      // auto-fixable: Disallow unnecessary curly braces in JSX props and/or children.
+      "react/jsx-curly-brace-presence": [
+        "error",
+        {
+          props: "never",
+          children: "never",
+          // JSX prop values that are JSX elements should be enclosed in braces.
+          propElementValues: "always",
+        },
+      ],
+      // not-auto-fixable: Disallow creating unstable components inside components.
+      "react/no-unstable-nested-components": ["error", { allowAsProps: true }],
+      // not-auto-fixable: Disallow missing React when using JSX.
+      "react/react-in-jsx-scope": "off",
+      // not-auto-fixable: Prevent React to be incorrectly marked as unused.
+      "react/jsx-uses-react": "off",
+    },
+  },
+]);

package/configs/jest/prevalTransformer.js

@@ -0,0 +1,33 @@
+const { createTransformer } = require("babel-jest");
+
+const { prevalReplace } = require("../utils/prevalReplace");
+
+const babelTransformer = createTransformer();
+
+module.exports = {
+  ...babelTransformer,
+  getCacheKey(sourceText, sourcePath, options) {
+    const replaced = prevalReplace(sourceText);
+    const code = replaced ?? sourceText;
+
+    return babelTransformer.getCacheKey(code, sourcePath, options);
+  },
+  process(sourceText, sourcePath, options) {
+    const replaced = prevalReplace(sourceText);
+    const code = replaced ?? sourceText;
+
+    return babelTransformer.process(code, sourcePath, options);
+  },
+  processAsync(sourceText, sourcePath, options) {
+    const replaced = prevalReplace(sourceText);
+    const code = replaced ?? sourceText;
+
+    return babelTransformer.processAsync(code, sourcePath, options);
+  },
+  getCacheKeyAsync(sourceText, sourcePath, options) {
+    const replaced = prevalReplace(sourceText);
+    const code = replaced ?? sourceText;
+
+    return babelTransformer.getCacheKeyAsync(code, sourcePath, options);
+  },
+};

package/configs/nanos/eslint/imports/order.mjs

@@ -0,0 +1,44 @@
+import { defineConfig } from "eslint/config";
+
+import buildPathGroupsBasedOnWebpackAliases from "../../../eslint/helpers/index.mjs";
+
+const pathGroups =
+  buildPathGroupsBasedOnWebpackAliases.buildPathGroupsBasedOnWebpackAliases({
+    customAliasPath: "resolve.js",
+    commonAliasPath:
+      "node_modules/@bigbinary/neeto-commons-frontend/configs/nanos/webpack/resolve.js",
+  });
+
+const pathGroupForKeepingReactImportsAtTop = {
+  pattern: "react+(-native|)",
+  group: "external",
+  position: "before",
+};
+pathGroups.push(pathGroupForKeepingReactImportsAtTop);
+
+export default defineConfig([
+  {
+    rules: {
+      "import/order": [
+        "error",
+        {
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true },
+          warnOnUnassignedImports: true,
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            "index",
+            "sibling",
+            "parent",
+            "object",
+            "type",
+          ],
+          pathGroups,
+          pathGroupsExcludedImportTypes: ["react", "react-native"],
+        },
+      ],
+    },
+  },
+]);

package/configs/nanos/eslint/index.mjs

@@ -0,0 +1,29 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { FlatCompat } from "@eslint/eslintrc";
+import { defineConfig } from "eslint/config";
+
+import orderConfig from "./imports/order.mjs";
+
+import commonConfiguration from "../../eslint/index.mjs";
+import globalsConfig from "../../eslint/globals.mjs";
+import enforcedConfig from "../../eslint/imports/enforced.mjs";
+import overridesConfig from "../../eslint/overrides.mjs";
+import promiseConfig from "../../eslint/promise.mjs";
+import reactConfig from "../../eslint/react.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({ baseDirectory: __dirname });
+
+export default defineConfig([
+  ...commonConfiguration,
+  ...compat.extends("plugin:@bigbinary/neeto/nanos-recommended"),
+  globalsConfig,
+  orderConfig,
+  overridesConfig,
+  enforcedConfig,
+  reactConfig,
+  promiseConfig,
+]);

package/configs/nanos/rollup/watchConfig.js

@@ -0,0 +1,136 @@
+/* eslint-disable security/detect-non-literal-fs-filename */
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+
+import { globby } from "globby";
+import copy from "rollup-plugin-copy";
+
+const require = createRequire(import.meta.url);
+
+const getAppArg = () => {
+  const argv = process.argv.slice(2);
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--app" && argv[i + 1] && !argv[i + 1].startsWith("--")) {
+      return argv[i + 1];
+    }
+
+    if (argv[i].startsWith("--app=")) {
+      return argv[i].split("=")[1];
+    }
+  }
+
+  return null;
+};
+
+const invalidateYarnCache = destination => {
+  const nodeModulesDir = path.resolve(destination, "../..");
+
+  // Yarn 1.x uses .yarn-integrity
+  const integrityPath = path.join(nodeModulesDir, ".yarn-integrity");
+  if (fs.existsSync(integrityPath)) fs.unlinkSync(integrityPath);
+
+  // Yarn 4.x (with nodeLinker: node-modules) uses .yarn-state.yml
+  const statePath = path.join(nodeModulesDir, ".yarn-state.yml");
+  if (fs.existsSync(statePath)) fs.unlinkSync(statePath);
+};
+
+const emitReadyFile = (
+  destination,
+  { shouldInvalidateYarnCache = false } = {}
+) => ({
+  name: "emit-ready-file",
+  writeBundle: () => {
+    const markerPath = path.join(destination, ".ready");
+
+    require("fs").writeFileSync(
+      markerPath,
+      `Built at ${new Date().toISOString()}`
+    );
+
+    if (shouldInvalidateYarnCache) invalidateYarnCache(destination);
+  },
+});
+
+const watchPaths = customWatchPaths => ({
+  name: "watch-translations",
+  async buildStart() {
+    const pathsToWatch = [];
+
+    if (fs.existsSync("app/javascript/src/translations")) {
+      pathsToWatch.push("app/javascript/src/translations");
+    } else if (fs.existsSync("src/translations")) {
+      pathsToWatch.push("src/translations");
+    }
+
+    if (fs.existsSync("typeTemplates")) {
+      pathsToWatch.push("typeTemplates/**/*");
+    } else {
+      pathsToWatch.push("types/**/*");
+      pathsToWatch.push("*.d.ts");
+    }
+
+    if (customWatchPaths && customWatchPaths.length) {
+      pathsToWatch.push(...customWatchPaths);
+    }
+
+    const matchedPaths = await globby(pathsToWatch);
+
+    matchedPaths.forEach(p => this.addWatchFile(path.resolve(p)));
+  },
+});
+
+const copyFiles = (destination, customCopyPaths) =>
+  copy({
+    targets: [
+      { src: "package.json", dest: destination },
+      { src: "*.d.ts", dest: destination },
+      { src: "types/", dest: destination },
+      { src: "LICENSE.md", dest: destination },
+      { src: "src/translations", dest: path.join(destination, "src") },
+      {
+        src: "app/javascript/src/translations",
+        dest: path.join(destination, "app/javascript/src"),
+      },
+      ...customCopyPaths.map(p => ({
+        src: p.src,
+        dest: path.join(destination, p.dest),
+      })),
+    ],
+  });
+
+const getWatchConfig = ({
+  customCopyPaths = [],
+  customWatchPaths = [],
+} = {}) => {
+  const appArg = getAppArg();
+
+  const currentDir = process.cwd();
+
+  if (!appArg) {
+    return {
+      watchPlugins: [emitReadyFile(path.resolve(currentDir, "dist"))],
+      appPath: null,
+    };
+  }
+
+  const packageJson = require(path.resolve(currentDir, "package.json"));
+
+  const appPath = path.resolve(
+    currentDir,
+    appArg,
+    "node_modules",
+    packageJson.name
+  );
+
+  const watchPlugins = [
+    watchPaths(customWatchPaths),
+    copyFiles(appPath, customCopyPaths),
+    emitReadyFile(appPath, { shouldInvalidateYarnCache: true }),
+  ];
+
+  return { watchPlugins, appPath };
+};
+
+export { getWatchConfig };

package/configs/nanos/webpack/resolve.js

@@ -25,12 +25,36 @@ module.exports = {
     utils: `${srcPath}/utils`,
     src: srcPath,
     neetoui: "@bigbinary/neetoui",
+    neetoatoms: "@bigbinary/neeto-atoms",
     neetocommons: "@bigbinary/neeto-commons-frontend",
+    neetointegrations: "@bigbinary/neeto-integrations-frontend",
+    neetothemes: "@bigbinary/neeto-themes-frontend",
+    neetoslack: "@bigbinary/neeto-slack-frontend",
+    neetorules: "@bigbinary/neeto-rules-frontend",
+    neetoapprovals: "@bigbinary/neeto-approvals-frontend",
+    neetofields: "@bigbinary/neeto-fields-frontend",
+    neetofolders: "@bigbinary/neeto-folders-frontend",
+    neetoredirecturls: "@bigbinary/neeto-redirect-urls-frontend",
+    neetogithub: "@bigbinary/neeto-github-frontend",
+    neetoratelimit: "@bigbinary/neeto-rate-limit-frontend",
+    neetoaccesscontrol: "@bigbinary/neeto-access-control-frontend",
+    neetotags: "@bigbinary/neeto-tags-frontend",
+    neetoactivities: "@bigbinary/neeto-activities-frontend",
+    neetotemplates: "@bigbinary/neeto-templates-frontend",
+    neetoapikeys: "@bigbinary/neeto-api-keys-frontend",
+    neetoemailnotifications: "@bigbinary/neeto-email-notifications-frontend",
+    neetothankyou: "@bigbinary/neeto-thank-you-frontend",
+    neetoimageuploader: "@bigbinary/neeto-image-uploader-frontend",
+    neetowebhooks: "@bigbinary/neeto-webhooks-frontend",
+    neetoform: "@bigbinary/neeto-form-frontend",
+    neetoprojects: "@bigbinary/neeto-projects-frontend",
+    neetomessagetemplates: "@bigbinary/neeto-message-templates-frontend",
     neetoicons: "@bigbinary/neeto-icons",
     neetoteam: "@bigbinary/neeto-team-members-frontend",
-    neetoeditor: "@bigbinary/neeto-editor",
+    neetoeditor: "@bigbinary/neeto-editor-frontend",
     neetofilters: "@bigbinary/neeto-filters-frontend",
     neetomolecules: "@bigbinary/neeto-molecules",
+    neetopayments: "@bigbinary/neeto-payments-frontend",
     neetocist: "@bigbinary/neeto-cist",
     neetohotkeys: "@bigbinary/neeto-hotkeys",
   },

package/configs/nextjs/eslint/imports/order.mjs

@@ -0,0 +1,46 @@
+import { defineConfig } from "eslint/config";
+
+import buildPathGroupsBasedOnWebpackAliases from "../../../eslint/helpers/index.mjs";
+import commonConfig from "../../../eslint/imports/order.mjs";
+
+const pathGroups =
+  buildPathGroupsBasedOnWebpackAliases.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);
+
+export default defineConfig([
+  {
+    rules: {
+      "import/order": [
+        "error",
+        {
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true },
+          warnOnUnassignedImports: true,
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            "index",
+            "sibling",
+            "parent",
+            "object",
+            "type",
+          ],
+          pathGroups,
+          pathGroupsExcludedImportTypes: ["react", "react-native"],
+        },
+      ],
+    },
+  },
+  ...commonConfig,
+]);

package/configs/nextjs/eslint/index.mjs

@@ -0,0 +1,29 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { FlatCompat } from "@eslint/eslintrc";
+import { defineConfig } from "eslint/config";
+
+import orderConfig from "./imports/order.mjs";
+
+import commonConfiguration from "../../eslint/index.mjs";
+import globalsConfig from "../../eslint/globals.mjs";
+import enforcedConfig from "../../eslint/imports/enforced.mjs";
+import overridesConfig from "../../eslint/overrides.mjs";
+import promiseConfig from "../../eslint/promise.mjs";
+import reactConfig from "../../eslint/react.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({ baseDirectory: __dirname });
+
+export default defineConfig([
+  ...commonConfiguration,
+  ...compat.extends("plugin:@bigbinary/neeto/nextjs-recommended"),
+  globalsConfig,
+  orderConfig,
+  overridesConfig,
+  enforcedConfig,
+  reactConfig,
+  promiseConfig,
+]);

package/configs/prettier.js

@@ -1,4 +1,5 @@
 module.exports = {
+  plugins: ["prettier-plugin-tailwindcss"],
   tailwindConfig: "./tailwind.config.js",
   trailingComma: "es5",
   arrowParens: "avoid",

package/configs/scripts/buildTranslationImports.js

@@ -0,0 +1,21 @@
+const fs = require("fs");
+const path = require("path");
+
+const getTranslationImports = () => {
+  const translationsDir = path.resolve("dist/translations");
+
+  const files = fs
+    .readdirSync(translationsDir)
+    .filter(file => file.endsWith(".json"));
+
+  // Create a map like { "en": () => import("dist/translations/en.json") }
+  const entries = files.map(file => {
+    const lang = path.basename(file, ".json");
+
+    return `"${lang}": () => import("${process.cwd()}/dist/translations/${file}")`;
+  });
+
+  return `{ ${entries.join(",\n")} }`;
+};
+
+module.exports = getTranslationImports;

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

@@ -10,7 +10,7 @@ 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 { isEmpty, includes, __, mergeDeepLeft } = require("ramda");
 
 const {
   RAILS_MOUNTED_COMPONENTS_REGEX,
@@ -20,8 +20,14 @@ const {
 } = require("./constants");
 
 // @ts-ignore
-// eslint-disable-next-line import/extensions
-const webpackConfig = require("../../../../../../config/webpack/webpack.config.js");
+const projectESBuildConfig = require("../../../../../../config/esbuild/config");
+const baseESBuildAlias = require("../../esbuild/alias");
+const baseESBuildExtensions = require("../../esbuild/index");
+
+const mergedESBuildAlias = mergeDeepLeft(
+  projectESBuildConfig.alias,
+  baseESBuildAlias
+);
 
 let modifiedFiles = [];
 let importedItems = [];
@@ -34,10 +40,8 @@ const javascriptDir = pathLib.resolve(
 );
 
 const resolver = enhancedResolve.create.sync({
-  alias: webpackConfig.resolve.alias,
-  modules: webpackConfig.resolve.modules,
-  extensions: webpackConfig.resolve.extensions,
-  fallback: webpackConfig.resolve.fallback,
+  alias: mergedESBuildAlias,
+  extensions: baseESBuildExtensions.config.resolveExtensions,
   conditionNames: ["require", "import", "node", "default", "types"],
 });
 
@@ -63,24 +67,98 @@ const findImports = filePath => {
       const currentDir = pathLib.dirname(filePath);
       const importSource = node.source.value;
 
-      const resolvedPath = resolver(currentDir, importSource);
-      const isNodeModule = resolvedPath.includes("node_modules");
-      if (isNodeModule) return;
+      try {
+        const resolvedPath = resolver(currentDir, importSource);
+        const isNodeModule = resolvedPath.includes("node_modules");
+        if (isNodeModule) return;
+
+        if (isEmpty(node.specifiers)) {
+          importedItems.push({ item: "*", filePath: resolvedPath });
+        }
 
-      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 });
+          }
+        });
+      } catch (err) {
+        // Skip resolution errors (e.g., malformed package exports in node_modules)
+        // This typically happens with external packages that have invalid exports(like BrowserPreview in          neeto-molecules)
+        console.warn(
+          `Failed to resolve import "${importSource}" in ${filePath}: ${err.message}`
+        );
+
+        return;
       }
+    },
+
+    // Handle React.lazy(() => import("...")) patterns and dynamic imports
+    CallExpression(path) {
+      const { node } = path;
+
+      // Check for React.lazy pattern
+      if (
+        node.callee.type === "MemberExpression" &&
+        node.callee.object.name === "React" &&
+        node.callee.property.name === "lazy" &&
+        node.arguments.length === 1 &&
+        node.arguments[0].type === "ArrowFunctionExpression"
+      ) {
+        const arrowFunction = node.arguments[0];
+        if (
+          arrowFunction.body.type === "CallExpression" &&
+          arrowFunction.body.callee.type === "Import"
+        ) {
+          const importArg = arrowFunction.body.arguments[0];
+          if (importArg && importArg.type === "StringLiteral") {
+            const currentDir = pathLib.dirname(filePath);
+            const importSource = importArg.value;
+
+            try {
+              const resolvedPath = resolver(currentDir, importSource);
+              if (!resolvedPath || typeof resolvedPath !== "string") return;
+
+              const isNodeModule = resolvedPath.includes("node_modules");
+              if (isNodeModule) return;
+
+              importedItems.push({ item: "default", filePath: resolvedPath });
+            } catch (err) {
+              console.warn(
+                `⚠️  Failed to resolve React.lazy import "${importSource}" in ${filePath}: ${err.message}`
+              );
+            }
+          }
+        }
+      }
+
+      // Handle direct dynamic imports: import("...")
+      if (
+        node.callee.type === "Import" &&
+        node.arguments.length === 1 &&
+        node.arguments[0].type === "StringLiteral"
+      ) {
+        const currentDir = pathLib.dirname(filePath);
+        const importSource = node.arguments[0].value;
+
+        try {
+          const resolvedPath = resolver(currentDir, importSource);
+          if (!resolvedPath || typeof resolvedPath !== "string") return;
+
+          const isNodeModule = resolvedPath.includes("node_modules");
+          if (isNodeModule) return;
 
-      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 });
+        } catch (err) {
+          console.warn(
+            `Failed to resolve dynamic import "${importSource}" in ${filePath}: ${err.message}`
+          );
         }
-      });
+      }
     },
   });
 };
@@ -233,7 +311,9 @@ const run = () => {
   importedItems = [];
   unusedFiles = [];
 
-  console.log("* Collecting all the imports.");
+  console.log(
+    "* Collecting all the imports (including React.lazy and dynamic imports)."
+  );
   traverseDirectoryAndExecuteFunc(javascriptDir, findImports);
 
   console.log("* Removing exports which are not imported.");

package/configs/scripts/getEnglishTranslation.js

@@ -0,0 +1,11 @@
+const fs = require("fs");
+const path = require("path");
+
+const getEnglishTranslations = () => {
+  const filePath = path.resolve(process.cwd(), "dist/translations/en.json");
+  const content = fs.readFileSync(filePath, "utf8");
+
+  return JSON.parse(content);
+};
+
+module.exports = getEnglishTranslations;