@openedx/frontend-base 1.0.0-alpha.0

package/tools/cli/intl-imports.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+const scriptHelpDocument = `
+NAME
+  intl-imports.js — Script to generate the src/i18n/index.js file that exports messages from all the languages for Micro-frontends.
+
+SYNOPSIS
+  intl-imports.js [DIRECTORY ...]
+
+DESCRIPTION
+  This script is intended to run after 'atlas' has pulled the files.
+
+  This expects to run inside a Micro-frontend root directory with the following structure:
+
+    frontend-app-learning $ tree src/i18n/
+    src/i18n/
+    ├── index.js
+    └── messages
+        ├── frontend-app-example
+        │   ├── ar.json
+        │   ├── es_419.json
+        │   └── zh_CN.json
+        ├── frontend-component-footer
+        │   ├── ar.json
+        │   ├── es_419.json
+        │   └── zh_CN.json
+        └── frontend-component-header (empty directory)
+
+
+
+  With the structure above it's expected to run with the following command in Makefile:
+
+
+    $ node_modules/.bin/intl-imports.js frontend-component-footer frontend-component-header frontend-app-example
+
+
+  It will generate two type of files:
+
+   - Main src/i18n/index.js which overrides the Micro-frontend provided with a sample output of:
+
+      """
+      import messagesFromFrontendComponentFooter from './messages/frontend-component-footer';
+      // Skipped import due to missing './messages/frontend-component-footer/index.js' likely due to empty translations.
+      import messagesFromFrontendAppExample from './messages/frontend-app-example';
+
+      export default [
+        messagesFromFrontendComponentFooter,
+        messagesFromFrontendAppExample,
+      ];
+      """
+
+   - Each sub-directory has src/i18n/messages/frontend-component-header/index.js which is imported by the main file.:
+
+      """
+      import messagesOfArLanguage from './ar.json';
+      import messagesOfDeLanguage from './de.json';
+      import messagesOfEs419Language from './es_419.json';
+      export default {
+        'ar': messagesOfArLanguage,
+        'de': messagesOfDeLanguage,
+        'es-419': messagesOfEs419Language,
+      };
+     """
+`;
+
+import fs from 'fs';
+import camelCase from 'lodash.camelcase';
+import path from 'path';
+
+const loggingPrefix = path.basename(`${__filename}`); // the name of this JS file
+
+// Header note for generated src/i18n/index.js file
+const filesCodeGeneratorNoticeHeader = `// This file is generated by the openedx/frontend-base's "intl-import.js" script.
+//
+// Refer to the i18n documents in https://docs.openedx.org/en/latest/developers/references/i18n.html to update
+// the file and use the Micro-frontend i18n pattern in new repositories.
+//
+`;
+
+/**
+ * Create frontend-app-example/index.js file with proper imports.
+ *
+ * @param directory - a directory name containing .json files from Transifex e.g. "frontend-app-example".
+ * @param log - Mockable process.stdout.write
+ * @param writeFileSync - Mockable fs.writeFileSync
+ * @param i18nDir - Path to `src/i18n` directory
+ *
+ * @return object - An object containing directory name and whether its "index.js" file was successfully written.
+ */
+function generateSubdirectoryMessageFile({
+  directory,
+  log,
+  writeFileSync,
+  i18nDir,
+}: {
+  directory: string,
+  log: (message: string) => void,
+  writeFileSync: (filename: string, content: string) => void,
+  i18nDir: string,
+
+}) {
+  const importLines: string[] = [];
+  const messagesLines: string[] = [];
+  const counter = { nonEmptyLanguages: 0 };
+  const messagesDir = `${i18nDir}/messages`; // The directory of Micro-frontend i18n messages
+
+  try {
+    const files = fs.readdirSync(`${messagesDir}/${directory}`, { withFileTypes: true });
+    files.sort(); // Sorting ensures a consistent generated `index.js` order of imports cross-platforms.
+
+    const jsonFiles = files.filter(file => file.isFile() && file.name.endsWith('.json'));
+
+    if (!jsonFiles.length) {
+      log(`${loggingPrefix}: Not creating '${directory}/index.js' because no .json translation files were found.\n`);
+      return {
+        directory,
+        isWritten: false,
+      };
+    }
+
+    jsonFiles.forEach((file) => {
+      const filename = file.name;
+      // Gets `fr_CA` from `fr_CA.json`
+      const languageCode = filename.replace(/\.json$/, '');
+      // React-friendly language code fr_CA --> fr-ca
+      const reactIntlLanguageCode = languageCode.toLowerCase().replace(/_/g, '-');
+      // camelCase variable name
+      const messagesCamelCaseVar = camelCase(`messages_Of_${languageCode}_Language`);
+      const filePath = `${messagesDir}/${directory}/${filename}`;
+
+      try {
+        const entries = JSON.parse(fs.readFileSync(filePath, { encoding: 'utf8' }));
+
+        if (!Object.keys(entries).length) {
+          importLines.push(`// Note: Skipped empty '${filename}' messages file.`);
+          return; // Skip the language
+        }
+      } catch (e) {
+        importLines.push(`// Error: unable to parse '${filename}' messages file.`);
+        log(`${loggingPrefix}: NOTICE: Skipping '${directory}/${filename}' due to error: ${e}.\n`);
+        return; // Skip the language
+      }
+
+      counter.nonEmptyLanguages += 1;
+      importLines.push(`import ${messagesCamelCaseVar} from './${filename}';`);
+      messagesLines.splice(1, 0, `  '${reactIntlLanguageCode}': ${messagesCamelCaseVar},`);
+    });
+
+    if (counter.nonEmptyLanguages) {
+      // See the help message above for sample output.
+      const messagesFileContent = [
+        filesCodeGeneratorNoticeHeader,
+        importLines.join('\n'),
+        '\nexport default {',
+        messagesLines.join('\n'),
+        '};\n',
+      ].join('\n');
+
+      writeFileSync(`${messagesDir}/${directory}/index.js`, messagesFileContent);
+      return {
+        directory,
+        isWritten: true,
+      };
+    }
+    log(`${loggingPrefix}: Skipping '${directory}' because no languages were found.\n`);
+  } catch (e) {
+    log(`${loggingPrefix}: NOTICE: Skipping '${directory}' due to error: ${e}.\n`);
+  }
+
+  return {
+    directory,
+    isWritten: false,
+  };
+}
+
+/**
+ * Create main `src/i18n/index.js` messages import file.
+ *
+ *
+ * @param processedDirectories - List of directories with a boolean flag whether its "index.js" file is written
+ *                               The format is "[\{ directory: "frontend-component-example", isWritten: false \}, ...]"
+ * @param log - Mockable process.stdout.write
+ * @param writeFileSync - Mockable fs.writeFileSync
+ * @param i18nDir` - Path to `src/i18n` directory
+ */
+function generateMainMessagesFile({
+  processedDirectories,
+  log,
+  writeFileSync,
+  i18nDir,
+}: {
+  processedDirectories: { directory: string, isWritten: boolean }[],
+  log: (message: string) => void,
+  writeFileSync: (filename: string, content: string) => void,
+  i18nDir: string,
+}) {
+  const importLines: string[] = [];
+  const exportLines: string[] = [];
+
+  processedDirectories.forEach(processedDirectory => {
+    const { directory, isWritten } = processedDirectory;
+    if (isWritten) {
+      const moduleCamelCaseVariableName = camelCase(`messages_from_${directory}`);
+      importLines.push(`import ${moduleCamelCaseVariableName} from './messages/${directory}';`);
+      exportLines.push(`  ${moduleCamelCaseVariableName},`);
+    } else {
+      const skipMessage = `Skipped import due to missing '${directory}/index.js' likely due to empty translations.`;
+      importLines.push(`// ${skipMessage}.`);
+      log(`${loggingPrefix}: ${skipMessage}\n`);
+    }
+  });
+
+  // See the help message above for sample output.
+  const indexFileContent = [
+    filesCodeGeneratorNoticeHeader,
+    importLines.join('\n'),
+    '\nexport default [',
+    exportLines.join('\n'),
+    '];\n',
+  ].join('\n');
+
+  writeFileSync(`${i18nDir}/index.js`, indexFileContent);
+}
+
+/*
+ * Main function of the file.
+ */
+export function main({
+  directories,
+  log,
+  writeFileSync,
+  pwd,
+}: {
+  directories: string | string[],
+  log: (message: string) => void,
+  writeFileSync: (filename: string, content: string) => void,
+  pwd: string,
+}) {
+  const i18nDir = `${pwd}/src/i18n`; // The Micro-frontend i18n root directory
+
+  if (directories.includes('--help') || directories.includes('-h')) {
+    log(scriptHelpDocument);
+  } else if (!directories.length) {
+    log(scriptHelpDocument);
+    log(`${loggingPrefix}: Error: A list of directories is required.\n`);
+  } else if (!fs.existsSync(i18nDir) || !fs.lstatSync(i18nDir).isDirectory()) {
+    log(scriptHelpDocument);
+    log(`${loggingPrefix}: Error: src/i18n directory was not found.\n`);
+  } else {
+    // If we're here, we know that directories is an array, so cast it as one.
+    const processedDirectories = (directories as string[]).map((directory: string) => generateSubdirectoryMessageFile({
+      directory,
+      log,
+      writeFileSync,
+      i18nDir,
+    }));
+    generateMainMessagesFile({
+      processedDirectories,
+      log,
+      writeFileSync,
+      i18nDir,
+    });
+  }
+}
+
+if (require.main === module) {
+  // Run the main() function if called from the command line.
+  main({
+    directories: process.argv.slice(2),
+    log: text => process.stdout.write(text),
+    writeFileSync: fs.writeFileSync,
+    pwd: process.env.PWD ?? '.',
+  });
+}

package/tools/cli/openedx.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+
+import { existsSync } from 'fs';
+import path from 'path';
+import { CommandTypes, ConfigTypes } from '../types';
+import pack from './commands/pack';
+import release from './commands/release';
+import { ensureConfigFilenameOption } from './utils/ensureConfigFilenameOption';
+import prettyPrintTitle from './utils/prettyPrintTitle';
+import printUsage from './utils/printUsage';
+
+// commandName is the third argument after node and 'openedx'
+const commandName = process.argv[2];
+
+// remove 'openedx' from process.argv to allow subcommands to read options properly
+process.argv.splice(1, 1);
+
+let version;
+
+if (existsSync(path.resolve(__dirname, '../../package.json'))) {
+  version = require('../../package.json').version;
+} else if (existsSync(path.resolve(__dirname, '../../../package.json'))) {
+  version = require('../../../package.json').version;
+}
+
+prettyPrintTitle(`Open edX CLI v${version}`);
+
+switch (commandName) {
+  case CommandTypes.RELEASE:
+    release();
+    break;
+  case CommandTypes.PACK:
+    if (process.argv[2] === undefined) {
+      console.log(chalk.red(`${chalk.bold.red(commandName)} command usage: specify a peer folder where the command should install the package:
+
+      npm run pack my-project`));
+      process.exit(1);
+    }
+    pack();
+    break;
+  case CommandTypes.LINT:
+    ensureConfigFilenameOption(ConfigTypes.LINT, ['-c', '--config']);
+    require('.bin/eslint');
+    break;
+  case CommandTypes.TEST:
+    ensureConfigFilenameOption(ConfigTypes.TEST, ['-c', '--config']);
+    require('jest/bin/jest');
+    break;
+  case CommandTypes.BUILD:
+    ensureConfigFilenameOption(ConfigTypes.WEBPACK_BUILD, ['-c', '--config']);
+    require('webpack/bin/webpack');
+    break;
+  case CommandTypes.DEV:
+    ensureConfigFilenameOption(ConfigTypes.WEBPACK_DEV, ['-c', '--config']);
+    require('webpack-dev-server/bin/webpack-dev-server');
+    break;
+  case CommandTypes.DEV_SHELL:
+    ensureConfigFilenameOption(ConfigTypes.WEBPACK_DEV_SHELL, ['-c', '--config']);
+    require('webpack-dev-server/bin/webpack-dev-server');
+    break;
+  case CommandTypes.FORMAT_JS: {
+    /* The include option is used to specify which additional source folders to extract messages from.
+     * To extract more messages on other source folders use: --include=plugins --include=plugins2
+     * The intention use case is to allow extraction from the 'plugins' directory on 'frontend-app-authoring'.
+     * That plugins folder were kept outside the src folder to ensure they remain independent and
+     * can function without relying on the MFE environment's special features.
+     * This approach allows them to be packaged separately as NPM packages. */
+    const additionalSrcFolders = [] as string[];
+    process.argv.forEach((val, index) => {
+      if (val.startsWith('--include=')) {
+        additionalSrcFolders.push(val.split('=')[1]);
+        process.argv.splice(index, 1);
+      }
+    });
+    const srcFolders = ['src'].concat(additionalSrcFolders);
+    let srcFoldersString = srcFolders.join(',');
+    if (srcFolders.length > 1) {
+      srcFoldersString = `{${srcFoldersString}}`;
+    }
+    process.argv = process.argv.concat([
+      '--format', 'node_modules/@openedx/frontend-base/dist/tools/cli/utils/formatter.js',
+      '--ignore', `${srcFoldersString}/**/*.json`,
+      '--ignore', `${srcFoldersString}/**/*.d.ts`,
+      '--out-file', './temp/formatjs/Default.messages.json',
+      '--', `${srcFoldersString}/**/*.{j,t}s*`,
+    ]);
+    require('@formatjs/cli/bin/formatjs');
+    break;
+  }
+  case CommandTypes.SERVE:
+    require('./commands/serve');
+    break;
+  case CommandTypes.HELP:
+    printUsage();
+    break;
+  default:
+    console.log(`The command ${chalk.bold(commandName)} doesn't exist.`);
+    console.log('');
+    printUsage();
+}

package/tools/cli/transifex-utils.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import glob from 'glob';
+import path from 'path';
+
+/*
+ * See the Makefile for how the required hash file is downloaded from Transifex.
+ */
+
+/*
+ * Expected input: a directory, possibly containing subdirectories, with .json files.  Each .json
+ * file is an array of translation triplets (id, description, defaultMessage).
+ *
+ *
+ */
+function gatherJson(dir: string) {
+  const ret: { id: string, description: string, defaultMessage: string }[] = [];
+  const files = glob.sync(`${dir}/**/*.json`);
+
+  files.forEach((filename) => {
+    const messages = JSON.parse(fs.readFileSync(filename, { encoding: 'utf8' }));
+    ret.push(...messages);
+  });
+  return ret;
+}
+
+// the hash file returns ids whose periods are "escaped" (sort of), like this:
+// "key": "profile\\.sociallinks\\.social\\.links"
+// so our regular messageIds won't match them out of the box
+function escapeDots(messageId: string) {
+  return messageId.replace(/\./g, '\\.');
+}
+
+const jsonDir = process.argv[2];
+const messageObjects = gatherJson(jsonDir);
+
+if (messageObjects.length === 0) {
+  process.exitCode = 1;
+  throw new Error('Found no messages');
+}
+
+if (process.argv[3] === '--comments') { // prepare to handle the translator notes
+  const loggingPrefix = path.basename(`${__filename}`); // the name of this JS file
+  const bashScriptsPath = (
+    process.argv[4] && process.argv[4] === '--v3-scripts-path'
+      ? './node_modules/@edx/reactifex/bash_scripts'
+      : './node_modules/reactifex/bash_scripts');
+
+  const hashFile = `${bashScriptsPath}/hashmap.json`;
+  process.stdout.write(`${loggingPrefix}: reading hash file ${hashFile}\n`);
+  const messageInfo = JSON.parse(fs.readFileSync(hashFile, { encoding: 'utf8' }));
+
+  const outputFile = `${bashScriptsPath}/hashed_data.txt`;
+  process.stdout.write(`${loggingPrefix}: writing to output file ${outputFile}\n`);
+  fs.writeFileSync(outputFile, '');
+
+  messageObjects.forEach((message) => {
+    const transifexFormatId = escapeDots(message.id);
+
+    const info = messageInfo.find((mi: { key: string }) => mi.key === transifexFormatId);
+    if (info) {
+      fs.appendFileSync(outputFile, `${info.string_hash}|${message.description}\n`);
+    } else {
+      process.stdout.write(`${loggingPrefix}: string ${message.id} does not yet exist on transifex!\n`);
+    }
+  });
+} else {
+  const output: Record<string, string> = {};
+
+  messageObjects.forEach((message) => {
+    output[message.id] = message.defaultMessage;
+  });
+  fs.writeFileSync(process.argv[3], JSON.stringify(output, null, 2));
+}

package/tools/cli/utils/ensureConfigFilenameOption.ts

@@ -0,0 +1,40 @@
+import path from 'path';
+import { ConfigTypes } from '../../types';
+import getResolvedConfigPath from './getResolvedConfigPath';
+
+export function ensureConfigFilenameOption(configType: ConfigTypes, keys: string[]) {
+  let configFileName = null;
+  let fileNameIndex = null;
+  for (const key of keys) {
+    const index = process.argv.indexOf(key);
+    if (index !== -1) {
+      fileNameIndex = index + 1;
+      if (process.argv.length > fileNameIndex) {
+        configFileName = process.argv[fileNameIndex];
+      } else {
+        console.error(`You must specify a config filename as the next argument when using the ${key} flag. Aborting.`);
+        process.exit(1);
+      }
+    }
+  }
+
+  let customConfigFilePath = null;
+  if (configFileName !== null) {
+    customConfigFilePath = path.resolve(process.cwd(), configFileName);
+  }
+
+  const resolvedConfigPath = getResolvedConfigPath(customConfigFilePath, configType);
+
+  if (resolvedConfigPath === null) {
+    console.error(`No valid config file was found. Did you forget to create a config file? You may specify a custom path with the ${keys.join(' or ')} flag(s).`);
+    process.exit(1);
+  }
+
+  // If there wasn't a config flag on the command line, add one.
+  if (fileNameIndex === null) {
+    process.argv.push(keys[0]);
+    process.argv.push(resolvedConfigPath);
+  } else {
+    process.argv[fileNameIndex] = resolvedConfigPath;
+  }
+}

package/tools/cli/utils/formatter.ts

@@ -0,0 +1,10 @@
+exports.format = (messages: Record<string, { defaultMessage: string, description: string }>) => {
+  const results = Object.entries(messages).map(([id, message]) => (
+    {
+      id,
+      defaultMessage: message.defaultMessage,
+      description: message.description,
+    }
+  ));
+  return results;
+};

package/tools/cli/utils/getResolvedConfigPath.ts

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import { defaultConfigPaths } from '../../defaultConfigPaths';
+import { ConfigTypes } from '../../types';
+
+export default function getResolvedConfigPath(customConfigPath: string | null, configType: ConfigTypes) {
+  const configPaths = defaultConfigPaths[configType];
+
+  if (customConfigPath !== null) {
+    if (fs.existsSync(customConfigPath)) {
+      return customConfigPath;
+    } else {
+      console.error(`The custom config file at ${customConfigPath} does not exist. Aborting.`);
+      return null;
+    }
+  } else {
+    for (const configPath of configPaths) {
+      if (fs.existsSync(configPath)) {
+        return configPath;
+      }
+    }
+  }
+  return null;
+}

package/tools/cli/utils/prettyPrintTitle.ts

@@ -0,0 +1,15 @@
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+
+export default function prettyPrintTitle(title: string) {
+  const openedxGradient = gradient(['#B82669', '#22358C']);
+
+  const borderedTitle = `█ ${title} █`;
+
+  const whitespace = Array.from({ length: borderedTitle.length }, () => '█').join('');
+
+  console.log(chalk.bgWhite(openedxGradient(whitespace)));
+  console.log(chalk.bold.bgWhite(openedxGradient(borderedTitle)));
+  console.log(chalk.bgWhite(openedxGradient(whitespace)));
+  console.log('');
+}

package/tools/cli/utils/printUsage.ts

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+
+export default function printUsage() {
+  console.log('CLI Usage:\n');
+
+  console.group();
+  console.log('openedx <command> <options>\n');
+  console.groupEnd();
+
+  console.log('Commands:\n');
+
+  console.group();
+  console.log(`${chalk.bold('release')}\n`);
+  console.group();
+  console.log(`Compile source code for release as a library.  Compiled code is put into the dist folder.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('pack')} <peer folder>\n`);
+  console.group();
+  console.log(`Package the dist folder as an NPM-compatible .tgz file suitable for use with npm install, then install it in the specified peer folder.  The folder is assumed to be a peer of this repository, do not include a path.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('lint')} <eslint options>\n`);
+  console.group();
+  console.log(`Runs ESLint on the source code. Requires an ${chalk.bold('eslint.config.js')} file.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('test')} <jest options>\n`);
+  console.group();
+  console.log(`Runs Jest on the source code test suite. Requires a ${chalk.bold('jest.config.js')} file.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('build')}\n`);
+  console.group();
+  console.log(`Compiles the source code for deployment as a frontend site.  Requires a ${chalk.bold('site.config.build.tsx')} file.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('dev')}\n`);
+  console.group();
+  console.log(`Compiles the source code and serves it in Webpack dev server as a frontend site. Requires a ${chalk.bold('site.config.dev.tsx')} file.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('formatjs')}\n`);
+  console.group();
+  console.log(`Runs formatjs on the source code to extract internationalization messages.\n`);
+  console.groupEnd();
+
+  console.log(`${chalk.bold('serve')}\n`);
+  console.group();
+  console.log(`Serves the dist folder with an express server.  Used to locally test production assets.\n`);
+  console.groupEnd();
+  console.groupEnd();
+}

package/tools/config-helpers/createConfig.ts

@@ -0,0 +1,8 @@
+import { merge } from 'webpack-merge';
+import { ConfigTypes } from '../types';
+import getBaseConfig from './getBaseConfig';
+
+export default function createConfig(configType: ConfigTypes, configFragment: any = {}) {
+  const baseConfig = getBaseConfig(configType);
+  return merge(baseConfig, configFragment);
+};

package/tools/config-helpers/createLintConfig.ts

@@ -0,0 +1,14 @@
+import tseslint, { ConfigWithExtends } from 'typescript-eslint';
+import { ConfigTypes } from '../types';
+import getBaseConfig from './getBaseConfig';
+
+export default function createLintConfig(...configs: ConfigWithExtends[]) {
+  const baseConfig = getBaseConfig(ConfigTypes.LINT);
+
+  return tseslint.config(
+    {
+      extends: baseConfig,
+    },
+    ...configs,
+  );
+};

package/tools/config-helpers/getBaseConfig.ts

@@ -0,0 +1,11 @@
+import { defaultConfigPaths } from '../defaultConfigPaths';
+import { ConfigTypes } from '../types';
+
+export default function getBaseConfig(configType: ConfigTypes) {
+  const configPaths = defaultConfigPaths[configType];
+  if (configPaths === undefined) {
+    throw new Error(`openedx: ${configType} is not a supported config type.`);
+  }
+
+  return require(require.resolve(configPaths[configPaths.length - 1]));
+};

package/tools/defaultConfigPaths.ts

@@ -0,0 +1,30 @@
+import path from 'path';
+import { ConfigTypes } from './types';
+
+// These config paths are tested in the order they're defined, so the last ones are the last fallback.
+export const defaultConfigPaths = {
+  [ConfigTypes.BABEL]: [
+    path.resolve(process.cwd(), 'babel.config.js'),
+    path.resolve(__dirname, './babel/babel.config.js'),
+  ],
+  [ConfigTypes.WEBPACK_BUILD]: [
+    path.resolve(process.cwd(), 'webpack.config.build.js'),
+    path.resolve(__dirname, './webpack/webpack.config.build.js'),
+  ],
+  [ConfigTypes.WEBPACK_DEV]: [
+    path.resolve(process.cwd(), 'webpack.config.dev.js'),
+    path.resolve(__dirname, './webpack/webpack.config.dev.js'),
+  ],
+  [ConfigTypes.WEBPACK_DEV_SHELL]: [
+    path.resolve(process.cwd(), 'webpack.config.dev.shell.js'),
+    path.resolve(__dirname, './webpack/webpack.config.dev.shell.js'),
+  ],
+  [ConfigTypes.LINT]: [
+    path.resolve(process.cwd(), 'eslint.config.js'),
+    path.resolve(__dirname, './eslint/base.eslint.config.js'),
+  ],
+  [ConfigTypes.TEST]: [
+    path.resolve(process.cwd(), 'jest.config.js'),
+    path.resolve(__dirname, './jest/jest.config.js'),
+  ],
+};