@bigbinary/neeto-commons-frontend 3.0.6 → 3.0.9

package/cjs/configs/babel.js

@@ -0,0 +1,50 @@
+// eslint-disable-next-line @bigbinary/neeto/no-dangling-constants
+const VALID_ENVIRONMENTS = ["development", "test", "production"];
+
+module.exports = function (api) {
+  const currentEnv = api.env();
+  const isDevelopmentEnv = api.env("development");
+  const isProductionEnv = api.env("production");
+  const isTestEnv = api.env("test");
+
+  if (!VALID_ENVIRONMENTS.includes(currentEnv)) {
+    throw new Error(
+      "Please specify a valid `NODE_ENV` or `BABEL_ENV` environment variables. " +
+        'Valid values are "development", "test", and "production". ' +
+        `Instead, received: ${JSON.stringify(currentEnv)}.`
+    );
+  }
+
+  return {
+    presets: [
+      isTestEnv
+        ? [
+            "@babel/preset-env",
+            { targets: { node: "current" }, modules: "commonjs" },
+          ]
+        : [
+            "@babel/preset-env",
+            {
+              forceAllTransforms: isProductionEnv,
+              useBuiltIns: "entry",
+              corejs: "3.27.0",
+              modules: false,
+            },
+          ],
+      ["@babel/preset-react", { development: isDevelopmentEnv || isTestEnv }],
+      "@bigbinary/neeto",
+    ].filter(Boolean),
+    plugins: [
+      "preval",
+      "babel-plugin-macros",
+      "@babel/plugin-transform-runtime",
+      isTestEnv
+        ? "babel-plugin-dynamic-import-node" // tests run in node environment
+        : "@babel/plugin-syntax-dynamic-import",
+      isProductionEnv && [
+        "babel-plugin-transform-react-remove-prop-types",
+        { removeImport: true },
+      ],
+    ].filter(Boolean),
+  };
+};

package/cjs/configs/eslint/globals.js

@@ -0,0 +1,14 @@
+module.exports = {
+  // Globals can be disabled with the string "off"
+  // "writable" to allow the variable to be overwritten or "readonly" to disallow overwriting.
+  globals: {
+    Atomics: "readonly",
+    SharedArrayBuffer: "readonly",
+    // Makes logger function available everywhere. Else eslint will complaint of undef-var.
+    logger: "readonly",
+    module: "writable",
+    // Makes props obtained from Rails backend available everywhere in this project.
+    globalProps: "readonly",
+    preval: "readonly",
+  },
+};

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

@@ -0,0 +1,74 @@
+const fs = require("fs");
+const path = require("path");
+
+const { mergeDeepLeft, mergeLeft, keys } = require("ramda");
+
+const loadJS = jsPath => {
+  try {
+    return require(jsPath);
+  } catch {
+    return {};
+  }
+};
+
+const doesFileExist = filePath =>
+  fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+
+const generateAllPathsInsideDir = dirPath => {
+  const files = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  return files.flatMap(file => {
+    const filePath = path.join(dirPath, file.name);
+
+    return file.isDirectory() ? generateAllPathsInsideDir(filePath) : filePath;
+  });
+};
+
+const generatePathGroupsFromAssets = assetsPath => {
+  if (!fs.existsSync(assetsPath)) return [];
+
+  return generateAllPathsInsideDir(assetsPath).map(absPath => ({
+    pattern: absPath.replace(assetsPath, "").split(".")[0],
+    group: "internal",
+  }));
+};
+
+const buildPathGroupsBasedOnWebpackAliases = ({
+  customAliasPath = "config/webpack/resolve.js",
+  commonAliasPath = "node_modules/@bigbinary/neeto-commons-frontend/configs/webpack/resolve.js",
+}) => {
+  const rootOfProject = path.join(__dirname, "../../../../../../");
+  const projectResolve = loadJS(path.join(rootOfProject, customAliasPath));
+  const commonResolve = loadJS(path.join(rootOfProject, commonAliasPath));
+
+  const { dependencies = [], devDependencies = [] } = loadJS(
+    path.join(rootOfProject, "package.json")
+  );
+  const packages = keys(mergeLeft(dependencies, devDependencies));
+  const { alias = {}, extensions = [] } = mergeDeepLeft(
+    projectResolve,
+    commonResolve
+  );
+
+  const pathGroups = Object.entries(alias).flatMap(([pattern, aliasPath]) => {
+    const group = packages.includes(aliasPath) ? "external" : "internal";
+    const isFile = ["", ...extensions].some(extension =>
+      doesFileExist(`${aliasPath}${extension}`)
+    );
+
+    if (isFile) return { pattern, group };
+
+    return [
+      { pattern, group },
+      { pattern: `${pattern}/**`, group },
+    ];
+  });
+
+  const pathGroupsFromAssets = generatePathGroupsFromAssets(
+    path.join(rootOfProject, "app/assets/")
+  );
+
+  return pathGroups.concat(pathGroupsFromAssets);
+};
+
+module.exports = { buildPathGroupsBasedOnWebpackAliases };

package/cjs/configs/eslint/imports/enforced.js

@@ -0,0 +1,29 @@
+module.exports = {
+  rules: {
+    // not-auto-fixable: Prefer a default export if module exports a single name.
+    "import/prefer-default-export": "off",
+    // not-auto-fixable: Forbid a module from importing a module with a dependency path back to itself.
+    "import/no-cycle": ["warn", { maxDepth: 1, ignoreExternal: true }],
+    // not-auto-fixable: Prevent unnecessary path segments in import and require statements.
+    "import/no-useless-path-segments": ["error", { noUselessIndex: true }],
+    // not-auto-fixable: Report any invalid exports, i.e. re-export of the same name.
+    "import/export": "error",
+    // not-auto-fixable: Forbid the use of mutable exports with var or let.
+    "import/no-mutable-exports": "error",
+    // not-auto-fixable: Ensure all imports appear before other statements.
+    "import/first": "error",
+    // not-auto-fixable: Ensure all exports appear after other statements.
+    "import/exports-last": "error",
+    // auto-fixable: Enforce a newline after import statements.
+    "import/newline-after-import": ["error", { count: 1 }],
+    // auto-fixable: Remove file extensions for import statements.
+    "import/extensions": [
+      "error",
+      "never",
+      {
+        ignorePackages: true,
+        pattern: { json: "always", ico: "always", yml: "always" },
+      },
+    ],
+  },
+};

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

@@ -0,0 +1,65 @@
+const { buildPathGroupsBasedOnWebpackAliases } = require("../helpers");
+
+const pathGroups = buildPathGroupsBasedOnWebpackAliases({});
+
+const pathGroupForKeepingReactImportsAtTop = {
+  pattern: "react+(-native|)",
+  group: "external",
+  position: "before",
+};
+
+/*
+Example pathGroups structure. Adding this here
+so that if anyone wants to add custom config,
+they can make use of this:
+[
+  { pattern: 'apis/**', group: 'internal' },
+  { pattern: 'common/**', group: 'internal' },
+  { pattern: 'components/**', group: 'internal' },
+  { pattern: 'constants/**', group: 'internal' },
+  { pattern: 'contexts/**', group: 'internal' },
+  { pattern: 'reducers/**', group: 'internal' },
+  { pattern: 'Constants', group: 'internal' },
+  { pattern: 'neetoui/**', group: 'external' },
+  {
+    pattern: 'react+(-native|)',
+    group: 'external',
+    position: 'before'
+  }
+]
+*/
+pathGroups.push(pathGroupForKeepingReactImportsAtTop);
+
+module.exports = {
+  rules: {
+    // auto-fixable: Enforce a convention in module import order - we enforce https://www.bigbinary.com/react-best-practices/sort-import-statements
+    "import/order": [
+      "error",
+      {
+        "newlines-between": "always",
+        alphabetize: { order: "asc", caseInsensitive: true },
+        warnOnUnassignedImports: true,
+        groups: [
+          "builtin",
+          "external",
+          "internal",
+          "index",
+          "sibling",
+          "parent",
+          "object",
+          "type",
+        ],
+        /*
+         * Currently we check for existence of webpack alias
+         * config and then iterate over the aliases and create
+         * these pathGroups. Only caveat with this mechanism
+         * is that in VSCode eslint plugin won't dynamically
+         * read it. But eslint cli would!
+         */
+        pathGroups,
+        // Ignore react imports so that they're always ordered to the top of the file.
+        pathGroupsExcludedImportTypes: ["react", "react-native"],
+      },
+    ],
+  },
+};

package/cjs/configs/eslint/index.js

@@ -0,0 +1,171 @@
+module.exports = {
+  env: {
+    browser: true, // window object etc part of browser are made available globally.
+    es2020: true, // to include BigInt support
+    es6: true,
+    commonjs: true,
+    node: true,
+  },
+  /*
+   * The order of extending each plugin matters a LOT!!
+   * Thus don't change order of items in this array
+   * unless you're sure of it.
+   */
+  extends: [
+    "plugin:@bigbinary/neeto/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/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",
+  ],
+  settings: {
+    react: { version: "detect" },
+    // We need this for the import/extensions rule to work: https://github.com/import-js/eslint-plugin-import#importextensions
+    "import/resolver": {
+      node: {
+        extensions: [".js", ".jsx", ".ts", ".tsx", ".svg", ".json"],
+      },
+    },
+  },
+  parserOptions: {
+    ecmaFeatures: { jsx: true },
+    ecmaVersion: 2018,
+    sourceType: "module",
+  },
+  // babel-eslint is deprecated now. This is the latest package.
+  parser: "@babel/eslint-parser",
+  plugins: [
+    "react",
+    "prettier",
+    "import",
+    "react-hooks",
+    "promise",
+    "jam3",
+    "unused-imports",
+    "sonarjs",
+    "security",
+    "xss",
+    "@bigbinary/neeto",
+  ],
+  rules: {
+    // auto-fixable: Respect all Prettier rules and apply it.
+    "prettier/prettier": "error",
+    // not-auto-fixable: No unused variables allowed.
+    "no-unused-vars": [
+      "error",
+      {
+        args: "all",
+        argsIgnorePattern: "^_",
+        destructuredArrayIgnorePattern: "^_",
+        caughtErrors: "all",
+      },
+    ],
+    // not-auto-fixable: No undefined variables allowed.
+    "no-undef": "error",
+    // not-auto-fixable: Dont use console statements. Use logger which babel will remove during bundling.
+    "no-console": "error",
+    // not-auto-fixable: require `return` statements to either always or never specify values.
+    "consistent-return": "error",
+    // auto-fixable: disallows repeating variable name when declaring object properties.
+    "object-shorthand": "error",
+    // auto-fixable: sadly this doesn't support guard clauses yet.
+    "padding-line-between-statements": [
+      "error",
+      { blankLine: "always", prev: "if", next: ["if", "return"] },
+      // The newline-before-return rule is deprecated in favor of the following:
+      { blankLine: "always", prev: "*", next: "return" },
+      // Add newline between function declarations
+      {
+        blankLine: "always",
+        prev: [
+          "block",
+          "multiline-block-like",
+          "function",
+          "iife",
+          "multiline-const",
+          "multiline-expression",
+        ],
+        next: ["function", "iife", "multiline-const", "multiline-expression"],
+      },
+    ],
+    // auto-fixable: Single line statements needn't have any braces. But in all other cases enforce curly braces.
+    curly: ["error", "multi-line"],
+    // auto-fixable: Remove the else part, if the "if" or "else-if" chain has a return statement
+    "no-else-return": "error",
+    // not-auto-fixable: Prevent un-sanitized dangerouslySetInnerHTML.
+    "jam3/no-sanitizer-with-danger": [
+      2,
+      { wrapperName: ["dompurify", "sanitizer", "sanitize"] },
+    ],
+    // auto-fixable: Requires trailing commas when the last element or property is in a different line than the closing ] or }
+    "comma-dangle": [
+      "error",
+      {
+        arrays: "always-multiline",
+        objects: "always-multiline",
+        imports: "always-multiline",
+        exports: "always-multiline",
+        functions: "never",
+      },
+    ],
+    // auto-fixable: If a variable is never reassigned, using the const declaration is better.
+    "prefer-const": "error",
+    // auto-fixable: It is considered good practice to use the type-safe equality operators === and !==.
+    eqeqeq: "error",
+    // not-auto-fixable: Rule flags optional chaining expressions in positions where short-circuiting to undefined causes throwing a TypeError afterward.
+    "no-unsafe-optional-chaining": "error",
+    // auto-fixable: Remove all unused imports.
+    "unused-imports/no-unused-imports": "error",
+    // auto-fixable-1-level-deep: Using nested ternary operators make the code unreadable. Use if/else or switch with if/else. If it's JSX then move it out into a function or a variable. It's fine to use nestedTernary in JSX when it makes code more readable.
+    "no-nested-ternary": "warn",
+    // auto-fixable: Enforces no braces where they can be omitted.
+    "arrow-body-style": ["error", "as-needed"],
+    // auto-fixable: Suggests using template literals instead of string concatenation.
+    "prefer-template": "error",
+    // auto-fixable: Disallows ternary operators when simpler alternatives exist.
+    "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+    // not-auto-fixable: Enforces declaring default params last
+    "default-param-last": "error",
+    // not-auto-fixable: Remove redundant async-awaits
+    "no-return-await": "warn",
+    // not-auto-fixable: Disallow empty block statements
+    "no-empty": ["error", { allowEmptyCatch: true }],
+    // not-auto-fixable: Enforce return statements in callbacks of array methods.
+    "array-callback-return": ["error"],
+    // auto-fixable: Partially fixable. Unless there's a need to the this keyword, there's no advantage of using a plain function.
+    "prefer-arrow-callback": ["error", { allowUnboundThis: true }],
+    // not-auto-fixable: Convert multiple imports from same module into a single import.
+    "no-duplicate-imports": ["error", { includeExports: true }],
+    // auto-fixable: Partially fixable. In JavaScript, there are a lot of different ways to convert value types. Allow only readable coercions.
+    "no-implicit-coercion": ["error", { allow: ["!!"] }],
+    // auto-fixable: Require let or const instead of var.
+    "no-var": "error",
+    // auto-fixable: This rule conflicts with prettier rules. Thus we've NOT kept this rule in react file. This rule ensures we don't add blank lines in JSX.
+    "react/jsx-newline": ["error", { prevent: true }],
+    // not-auto-fixable: Disallow async functions which have no await expression
+    "require-await": "error",
+    // auto-fixable: This rule ensures immediate returns in functions where constants are declared and then directly returned.
+    "sonarjs/prefer-immediate-return": "error",
+    // not-auto-fixable: This rule enforces merging adjacent collapsible if statements.
+    "sonarjs/no-collapsible-if": "error",
+    // not-auto-fixable: This rule prevents identical conditions inside if-else statements.
+    "sonarjs/no-identical-conditions": "error",
+    // not-auto-fixable: This rule prevents using a function with no return as output, passing it to another function, or assigning its result to a variable.
+    "sonarjs/no-use-of-empty-return-value": "error",
+    // not-auto-fixable: This rule prevents using loops with at most one iteration.
+    "sonarjs/no-one-iteration-loop": "error",
+    // not-auto-fixable: This rule prevents using catch clause that only throws an error.
+    "sonarjs/no-useless-catch": "error",
+    // not-auto-fixable: This rule warns against "eval(variable)" which can allow an attacker to run arbitrary code inside your process.
+    "security/detect-eval-with-expression": "warn",
+    // not-auto-fixable: This rule ensures that you are calling escape function before location.href assignment.
+    "xss/no-location-href-assign": ["error", { escapeFunc: "sanitize" }],
+  },
+};

package/cjs/configs/eslint/overrides.js

@@ -0,0 +1,30 @@
+module.exports = {
+  // Currently we are using this section for excluding certain files from certain rules.
+  overrides: [
+    {
+      files: [
+        ".eslintrc.js",
+        ".prettierrc.js",
+        "app/assets/**/*",
+        "app/javascript/packs/**/*",
+        "*.json",
+      ],
+      rules: {
+        "import/order": "off",
+        "react-hooks/rules-of-hooks": "off",
+      },
+    },
+    {
+      files: ["app/javascript/packs/**/*.{js,jsx}"],
+      rules: {
+        "no-redeclare": "off",
+      },
+    },
+    {
+      files: ["**/*.spec.js", "**/*.spec.jsx"],
+      env: {
+        jest: true,
+      },
+    },
+  ],
+};

package/cjs/configs/eslint/promise.js

@@ -0,0 +1,8 @@
+module.exports = {
+  rules: {
+    // not-auto-fixable: ensure people use async/await promising chaining rather than using "then-catch-finally" statements
+    "promise/prefer-await-to-then": "error",
+    // auto-fixable: avoid calling "new" on a Promise static method like reject, resolve etc
+    "promise/no-new-statics": "error",
+  },
+};

package/cjs/configs/eslint/react.js

@@ -0,0 +1,92 @@
+module.exports = {
+  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 React to be incorrectly marked as unused.
+    "react/jsx-uses-react": "error",
+    // 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",
+      },
+    ],
+  },
+};

package/cjs/configs/nanos/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/nanos/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/nanos/eslint/index.js

@@ -0,0 +1,28 @@
+const { mergeLeft } = require("ramda");
+
+const commonConfiguration = require("../../eslint");
+
+const isCommonsFrontend = !__dirname.includes("node_modules");
+
+const configsPath = isCommonsFrontend
+  ? "./configs"
+  : "./node_modules/@bigbinary/neeto-commons-frontend/configs";
+
+const nanosConfiguration = {
+  extends: [
+    "plugin:@bigbinary/neeto/nanos-recommended",
+    "plugin:cypress/recommended",
+    "plugin:json/recommended",
+    "eslint:recommended",
+    "plugin:react/recommended",
+    `${configsPath}/eslint/globals`,
+    `${configsPath}/nanos/eslint/imports/order`,
+    `${configsPath}/eslint/overrides`,
+    `${configsPath}/eslint/imports/enforced`,
+    `${configsPath}/eslint/react`,
+    `${configsPath}/eslint/promise`,
+    "prettier",
+  ],
+};
+
+module.exports = mergeLeft(nanosConfiguration, commonConfiguration);

package/cjs/configs/nanos/tailwind.js

@@ -0,0 +1,11 @@
+module.exports = {
+  important: true,
+  purge: {
+    enabled: process.env.NODE_ENV === "production",
+    content: [
+      "./{src,example,stories}/**/*.{js,jsx}",
+      "./node_modules/@bigbinary/**/*.js",
+    ],
+    defaultExtractor: content => content.match(/[A-Za-z0-9-_:/]+/g) || [],
+  },
+};

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

@@ -0,0 +1,48 @@
+const path = require("path");
+
+const isCommonsFrontend = !__dirname.includes("node_modules");
+
+const absolutePath = basePath =>
+  isCommonsFrontend
+    ? path.join(__dirname, "../../../", basePath)
+    : path.join(__dirname, "../../../../../../", basePath);
+
+module.exports = {
+  alias: {
+    apis: absolutePath("src/apis"),
+    assets: absolutePath("src/assets"),
+    components: absolutePath("src/components"),
+    hooks: absolutePath("src/hooks"),
+    reducers: absolutePath("src/reducers"),
+    routes: absolutePath("src/routes"),
+    stores: absolutePath("src/stores"),
+    translations: absolutePath("src/translations"),
+    utils: absolutePath("src/utils"),
+    src: absolutePath("src"),
+    neetoui: "@bigbinary/neetoui",
+    neetocommons: "@bigbinary/neeto-commons-frontend",
+    neetoicons: "@bigbinary/neeto-icons",
+    neetoteam: "@bigbinary/neeto-team-members-frontend",
+    neetoeditor: "@bigbinary/neeto-editor",
+    neetofilters: "@bigbinary/neeto-filters-frontend",
+    neetomolecules: "@bigbinary/neeto-molecules",
+    neetocist: "@bigbinary/neeto-cist",
+  },
+  extensions: [
+    ".ts",
+    ".mjs",
+    ".js",
+    ".jsx",
+    ".sass",
+    ".scss",
+    ".css",
+    ".module.sass",
+    ".module.scss",
+    ".module.css",
+    ".png",
+    ".svg",
+    ".gif",
+    ".jpeg",
+    ".jpg",
+  ],
+};