@elliemae/ds-monorepo-devops 3.60.0-next.5 → 3.60.0-next.50

package/bin/cli.mjs

@@ -3,13 +3,30 @@ import { checkCommandOrInquire, executeCommandsMap } from './execute-commands-ma
 
 function parseArgumentsIntoOptions(rawArgs) {
   const args = arg(
-    {},
+    {
+      '--passWithNoTests': Boolean,
+      '--silent': Boolean,
+      // the CI pipeline goes "runInBand"
+      //  but it was never implemented and it doesn't work so we allow and ignore the flag
+      '--runInBand': Boolean, // ignored
+      '--coverage': String,
+      '--maxWorkers': String,
+      '--filterFnFilePath': String,
+      '--testPathPatterns': String,
+    },
     {
       argv: rawArgs.slice(2),
     },
   );
   return {
     command: args._[0],
+    runInBand: args['--runInBand'], // CLI flag, not available as a question and ignored.
+    passWithNoTests: args['--passWithNoTests'], // CLI flag, not available as a question.
+    silent: args['--silent'], // CLI flag, not available as a question.
+    coverage: args['--coverage'], // CLI flag, not available as a question.
+    maxWorkers: args['--maxWorkers'], // CLI flag, not available as a question.
+    filterFnFilePath: args['--filterFnFilePath'], // CLI flag, not available as a question.
+    testPathPatterns: args['--testPathPatterns'], // CLI flag, not available as a question.
   };
 }
 

package/bin/execGitReverseMerge/index.mjs

@@ -1,11 +1,10 @@
 /* eslint-disable max-lines */
 /* eslint-disable max-len */
 /* eslint-disable complexity, no-console, max-statements */
-import defGlob from 'glob';
+import { glob } from 'glob';
 import inquirer from 'inquirer';
 import { exec } from 'node:child_process';
 import fs from 'node:fs';
-const { glob } = defGlob;
 
 const execSyntaxSugar = async ({ command, dryRun = false, silentFail = false }) => {
   const noLFNorCRLFCmd = command.replace(/\r?\n|\r/g, '');
@@ -24,7 +23,7 @@ const execSyntaxSugar = async ({ command, dryRun = false, silentFail = false })
   });
 };
 
-export async function promptForCommandOptions() {
+export async function promptForCommandOptions(options) {
   const preAnswears = await inquirer.prompt([
     {
       type: 'list',
@@ -72,6 +71,7 @@ export async function promptForCommandOptions() {
   const answers = await inquirer.prompt(questions);
 
   return {
+    ...options,
     ...answers,
   };
 }

package/bin/execSyncNxTags/index.mjs

@@ -1,9 +1,8 @@
 /* eslint-disable complexity, no-console, max-statements */
 import inquirer from 'inquirer';
-import defGlob from 'glob';
+import { glob } from 'glob';
 import path from 'node:path';
 import fs from 'node:fs';
-const { glob } = defGlob;
 
 export async function promptForCommandOptions(options) {
   const questions = [];
@@ -19,6 +18,7 @@ export async function promptForCommandOptions(options) {
   const answers = await inquirer.prompt(questions);
 
   return {
+    ...options,
     ...answers,
   };
 }

package/bin/execTest/index.mjs

@@ -0,0 +1,148 @@
+/* eslint-disable max-len */
+/* eslint-disable complexity, no-console, max-statements */
+import inquirer from 'inquirer';
+import { exec, getCIEnv, logError, logSuccess } from '../utils/index.mjs';
+
+/**
+ * @typedef {object} commandOptions
+ * @property {boolean} [commandOptions.passWithNoTests=true] - Indicates whether to pass the test command even if no tests are found.
+ * @property {boolean} [commandOptions.silent=false] - Indicates whether to run the test command in silent mode.
+ * @property {string} [commandOptions.coverage='false'] - Indicates whether to collect coverage information.
+ * @property {string} [commandOptions.maxWorkers='50%'] - Maximum number of workers the test command can use.
+ * @property {string} [commandOptions.filterFnFilePath=''] - Path to a module exporting a filtering function.
+ * @property {string} [commandOptions.testPathPatterns=''] - A regexp pattern string that is matched against all tests paths before executing the test.
+ */
+
+// we don't want this command to prompt for question, it is meant to be used in CI/CD or automated scripts
+// only flags provided via command line arguments will be used.
+export async function promptForCommandOptions(options) {
+  const questions = [];
+  // // flag bypasses this question
+  // if (!options.passWithNoTests) {
+  //   questions.push({
+  //     type: 'confirm',
+  //     name: 'passWithNoTests',
+  //     message: 'pass the test command even if no tests are found?',
+  //     default: true,
+  //   });
+  // }
+  // // --silent flag bypasses this question
+  // if (!options.silent) {
+  //   questions.push({
+  //     type: 'confirm',
+  //     name: 'silent',
+  //     message: 'run the test command in silent mode (no output unless error)?',
+  //     default: false,
+  //   });
+  // }
+  // // --coverage flag bypasses this question
+  // if (!options.coverage) {
+  //   questions.push({
+  //     type: 'list',
+  //     name: 'coverage',
+  //     message: 'collect coverage information?',
+  //     choices: ['true', 'false', 'CI'],
+  //     default: 'false',
+  //   });
+  // }
+  // // --maxWorkers flag bypasses this question
+  // if (!options.maxWorkers) {
+  //   questions.push({
+  //     type: 'input',
+  //     name: 'maxWorkers',
+  //     message: 'maximum number of workers the test command can use (number or percentage)?',
+  //     default: '50%',
+  //   });
+  // }
+  // // --filterFnFilePath flag bypasses this question
+  // if (!options.filterFnFilePath && !options.fffp) {
+  //   questions.push({
+  //     type: 'input',
+  //     name: 'filterFnFilePath',
+  //     message: 'Path to a module exporting a filtering function',
+  //     default: '',
+  //   });
+  // }
+  // // --testPathPatterns flag bypasses this question
+  // if (!options.testPathPatterns && !options.tpp) {
+  //   questions.push({
+  //     type: 'input',
+  //     name: 'testPathPatterns',
+  //     message: 'A regexp pattern string that is matched against all tests paths before executing the test',
+  //     default: '',
+  //   });
+  // }
+  const answers = await inquirer.prompt(questions);
+  return {
+    ...options,
+    ...answers,
+  };
+}
+
+/**
+ * Takes in command line arguments and returns a string of jest flags to be appended when invoking jest.
+ *
+ * @param {commandOptions} commandOptions - The command options.
+ * @returns {string}
+ */
+const getJestFlags = (commandOptions) => {
+  // with this we ensure the white spaces are correct without having to worry about them
+  const flagsArray = [commandOptions.maxWorkers ? `--maxWorkers=${commandOptions.maxWorkers}` : ''];
+  const isCi = getCIEnv();
+
+  // ******* Flags based on arguments *******
+  // coverage may be "CI" | "false" | "true"
+  switch (
+    `${commandOptions.coverage}` // the string cast is just to be sure commandOptions.coverage is a string no matter what
+  ) {
+    case 'CI':
+      if (isCi) {
+        flagsArray.push('--coverage');
+      }
+      break;
+    case 'false':
+      break;
+    case 'true':
+    default:
+      flagsArray.push('--coverage');
+      break;
+  }
+
+  // flags that depends on if the commandOptions was provided by the invoking command
+  if (commandOptions.passWithNoTests !== false && commandOptions.passWithNoTests !== 'false')
+    flagsArray.push('--passWithNoTests');
+  if (commandOptions.silent) flagsArray.push('--silent');
+  if (commandOptions.filterFnFilePath) flagsArray.push(`--filter=${commandOptions.filterFnFilePath}`);
+  if (commandOptions.testPathPatterns) flagsArray.push(`--testPathPatterns=${commandOptions.testPathPatterns}`);
+
+  // ******* automatic flags based on opinionated choices *******
+  if (isCi) flagsArray.push('--ci --no-colors');
+
+  return flagsArray.join(' ');
+};
+
+/**
+ * A wrapper of jest command execution with options provided via command line or prompted.
+ *
+ * Adapted from pui-cli but simplified and modified to fit ds-monorepo-devops usage within dimsum monorepo, not inheriting pui-cli tech debts and unused features.
+ * @param {commandOptions} commandOptions - The command options.
+ * @returns {Promise<void>}
+ */
+const runTests = async (commandOptions) => {
+  const jestFlags = getJestFlags(commandOptions);
+  try {
+    if (getCIEnv()) {
+      await exec('rimraf ./reports');
+    }
+    await exec(`cross-env NODE_ENV=test jest ${jestFlags}`);
+    logSuccess('Unit test execution completed');
+  } catch (err) {
+    logError('Unit test execution failed', err);
+    process.exit(-1);
+  }
+};
+
+export const execTest = async (options) => {
+  const commandOptions = await promptForCommandOptions(options);
+  await runTests(commandOptions);
+};

package/bin/execute-commands-map.mjs

@@ -2,11 +2,13 @@ import inquirer from 'inquirer';
 import { execSyncNxTags } from './execSyncNxTags/index.mjs';
 import { execGitReverseMerge } from './execGitReverseMerge/index.mjs';
 import { execForcePnpmCatalogVersions } from './forcePnpmCatalogVersions/index.mjs';
+import { execTest } from './execTest/index.mjs';
 
 const COMMANDS = {
   SYNC_NX_TAGS: 'sync-nx-tags',
   REVERSE_MERGE_BRANCH: 'reverse-merge-branch',
   FORCE_PNPM_CATALOG_VERSIONS: 'force-pnpm-catalog-versions',
+  TEST: 'test',
   EXIT: 'exit',
 };
 export const checkCommandOrInquire = async (options) => {
@@ -37,6 +39,9 @@ export async function executeCommandsMap(args, options) {
     case COMMANDS.FORCE_PNPM_CATALOG_VERSIONS:
       execForcePnpmCatalogVersions(options);
       break;
+    case COMMANDS.TEST:
+      execTest(options);
+      break;
     default:
       break;
   }

package/bin/forcePnpmCatalogVersions/index.mjs

@@ -1,9 +1,8 @@
 /* eslint-disable complexity, no-console, max-statements */
 import inquirer from 'inquirer';
-import defGlob from 'glob';
+import { glob } from 'glob';
 import path from 'node:path';
 import fs from 'node:fs';
-const { glob } = defGlob;
 
 export async function promptForCommandOptions(options) {
   const questions = [];
@@ -19,6 +18,7 @@ export async function promptForCommandOptions(options) {
   const answers = await inquirer.prompt(questions);
 
   return {
+    ...options,
     ...answers,
   };
 }

package/bin/utils/CLI_COLORS.mjs

@@ -0,0 +1,53 @@
+/* eslint-disable no-console */
+// https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+export const CLI_COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  underline: '\x1b[4m',
+  strikethrough: '\x1b[9m',
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  bgGray: '\x1b[100m',
+  bgBrightRed: '\x1b[101m',
+  bgBrightGreen: '\x1b[102m',
+  bgBrightYellow: '\x1b[103m',
+  bgBrightBlue: '\x1b[104m',
+  bgBrightMagenta: '\x1b[105m',
+  bgBrightCyan: '\x1b[106m',
+  bgBrightWhite: '\x1b[107m',
+};
+
+export const logRed = (...args) => {
+  console.log(CLI_COLORS.red, ...args, CLI_COLORS.reset);
+};
+export const logError = logRed;
+export const logYellow = (...args) => {
+  console.log(CLI_COLORS.yellow, ...args, CLI_COLORS.reset);
+};
+export const logGreen = (...args) => {
+  console.log(CLI_COLORS.green, ...args, CLI_COLORS.reset);
+};
+export const logSuccess = logGreen;

package/bin/utils/index.mjs

@@ -0,0 +1,6 @@
+import { execaCommand } from 'execa';
+
+export { logError, logGreen, logRed, logSuccess, logYellow } from './CLI_COLORS.mjs';
+
+export const exec = async (command, options = { stdio: 'inherit' }) => execaCommand(command, options);
+export const getCIEnv = () => process.env.CI === 'true';

package/configs/jest/jest.config.mjs

@@ -1,7 +1,7 @@
 /* eslint-disable max-len */
-import { jestConfig } from '@elliemae/pui-cli';
 import path from 'node:path';
 import { fileURLToPath } from 'url';
+import { jestConfig } from './testing/jest.config.base.mjs';
 
 const __filename = fileURLToPath(import.meta.url); // get the resolved path to the file
 const __dirname = path.dirname(__filename); // get the name of the directory
@@ -15,7 +15,7 @@ const getFileFromCurrentFolder = (fileName) => path.normalize(path.resolve(__dir
  * @returns {string[]} An array of setup files for Jest.
  */
 const getSetupFilesAfterEnvBasedOnFlags = ({ silenceConsole = false }) => {
-  const setupFilesAfterEnv = [getFileFromCurrentFolder('virtualListFix.mjs')];
+  const setupFilesAfterEnv = [];
 
   if (silenceConsole) {
     setupFilesAfterEnv.push(getFileFromCurrentFolder('noConsoleMode.mjs'));
@@ -66,12 +66,9 @@ export const config = ({ relativePathAfterTestsFolder = undefined, firstLevelSpr
       ? `.*/tests/${relativePathAfterTestsFolder}$`
       : 'tests/.*\\.test\\.[jt]sx?$',
     testTimeout: 120000,
-    setupFilesAfterEnv: [...jestConfig.setupFilesAfterEnv, ...getSetupFilesAfterEnvBasedOnFlags({ silenceConsole })],
+    setupFilesAfterEnv: [...getSetupFilesAfterEnvBasedOnFlags({ silenceConsole }), ...jestConfig.setupFilesAfterEnv],
     ...firstLevelSpread,
-    transformIgnorePatterns: [
-      ...jestConfig.transformIgnorePatterns,
-      // '/node_modules/(?!(\@elliemae\/pui-cli|lodash-es|react-select|react-dates|d3|internmap|delaunator|robust-predicates))/',
-    ],
+    transformIgnorePatterns: [...jestConfig.transformIgnorePatterns],
   };
 };
 export default config;

package/configs/jest/noConsoleMode.mjs

@@ -14,4 +14,4 @@ jest.mock('@testing-library/react', () => {
         : global.console.jestLog?.(prettyDOM(el, maxLength, options));
     },
   };
-});
+});

package/configs/jest/testing/.swcrc

@@ -0,0 +1,23 @@
+{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "jsx": true,
+      "tsx": true,
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "target": "es2022",
+    "transform": {
+      "react": {
+        "runtime": "automatic",
+        "importSource": "react",
+        "development":true,
+        "refresh": false
+      }
+    }
+  },
+  "module":{
+    "type":"commonjs"
+  }
+}

package/configs/jest/testing/jest-extended-dom.cjs

@@ -0,0 +1,27 @@
+const { setImmediate } = require('node:timers');
+const JSDOMEnvironment = require('jest-fixed-jsdom');
+
+class JSDOMEnvironmentExtended extends JSDOMEnvironment {
+  constructor(...args) {
+    super(...args);
+    const polyfillRAF = setImmediate;
+    if (!globalThis.requestAnimationFrame)
+      Object.defineProperties(globalThis, {
+        requestAnimationFrame: {
+          value: polyfillRAF,
+        },
+      });
+    if (!globalThis.window)
+      Object.defineProperties(globalThis, {
+        window: this.dom.window,
+      });
+    if (!this.dom.window.requestAnimationFrame)
+      Object.defineProperties(this.dom.window, {
+        requestAnimationFrame: {
+          value: polyfillRAF,
+        },
+      });
+  }
+}
+
+module.exports = JSDOMEnvironmentExtended;

package/configs/jest/testing/jest.config.base.mjs

@@ -0,0 +1,70 @@
+/* eslint-disable max-len */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import normalizePath from 'normalize-path';
+import { swcrcConfig } from './swcrc.config.cjs';
+import { findMonoRepoRoot } from './utils.cjs';
+
+const __filename = fileURLToPath(import.meta.url); // get the resolved path to the file
+const __dirname = path.dirname(__filename); // get the name of the directory
+
+const basePath = (process.env.BASE_PATH || '/').replace(/\/?$/, '/');
+
+const getMockFilePath = (fileName) => normalizePath(path.resolve(__dirname, './mocks', fileName));
+
+const getNodeModulesPath = (fileName) => {
+  const monorepoRoot = findMonoRepoRoot(process.cwd());
+  return normalizePath(
+    monorepoRoot ? path.join(monorepoRoot, 'node_modules', fileName) : `<rootDir>/node_modules/${fileName}`,
+  );
+};
+
+const configuredJestConfig = {
+  coverageThreshold: {},
+  coverageProvider: 'v8',
+  moduleDirectories: ['node_modules'],
+  moduleNameMapper: {
+    d3: '<rootDir>/node_modules/d3/dist/d3.min.js',
+    '^d3-(.*)$': '<rootDir>/node_modules/d3-$1/dist/d3-$1.min.js',
+    '.*\\webpack-hmr(.[t|j]s)?$': getMockFilePath('webpack-hmr.js'),
+    '.*\\.(css|scss)$': getMockFilePath('cssModule.js'),
+    '.*\\.(jpg|jpeg|png|gif|eot|otf|webp|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga|ico)$':
+      getMockFilePath('image.js'),
+    '.*\\.svg(?:\\?[a-zA-Z]+)?$': getMockFilePath('svg.js'),
+    '.*iframe\\.html(?:\\?[a-zA-Z]+)?$': getMockFilePath('iframe.js'),
+    '.*frame\\.html(?:\\?[a-zA-Z]+)?$': getMockFilePath('frame.js'),
+    '.*\\.html(?:\\?[a-zA-Z]+)?$': getMockFilePath('html.js'),
+    '@elliemae/pui-user-monitoring': getMockFilePath('pui-user-monitoring.js'),
+    '@elliemae/pui-app-loader': getMockFilePath('pui-app-loader.js'),
+    '@elliemae/pui-diagnostics': getMockFilePath('pui-diagnostics.js'),
+    'react-spring/web': getNodeModulesPath('react-spring/web.cjs.js'),
+    'react-spring/renderprops': getNodeModulesPath('react-spring/renderprops.cjs.js'),
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  setupFilesAfterEnv: [path.resolve(__dirname, './setup-tests.js'), path.resolve(__dirname, './setup-react-env.js')],
+  setupFiles: [],
+  snapshotSerializers: [],
+  testResultsProcessor: 'jest-sonar-reporter',
+  resolver: path.resolve(__dirname, './resolver.cjs'),
+  transform: {
+    '^.+\\.[jt]sx?$': ['@swc/jest', swcrcConfig],
+  },
+
+  transformIgnorePatterns: [
+    // eslint-disable-next-line no-useless-escape
+    '/node_modules/(?!(\@elliemae\/pui-cli|lodash-es|react-select|react-dates|d3|internmap|delaunator|robust-predicates))/',
+  ],
+  globals: {
+    __webpack_public_path__: '/',
+  },
+  testEnvironmentOptions: {
+    url: `http://localhost:3111${basePath}`,
+    resources: 'usable',
+    customExportConditions: [''],
+  },
+  testEnvironment: path.resolve(__dirname, './jest-extended-dom.cjs'),
+  watchPlugins: ['jest-watch-typeahead/filename', 'jest-watch-typeahead/testname'],
+  prettierPath: null,
+};
+
+export const jestConfig = configuredJestConfig;

package/configs/jest/testing/jest.node.config.cjs

@@ -0,0 +1,9 @@
+const { jestConfig } = require('./jest.config.cjs');
+exports.jestNodeConfig = {
+  ...jestConfig,
+  coverage: false,
+  testEnvironment: 'node',
+  transformIgnorePatterns: [],
+  setupFiles: [],
+  setupFilesAfterEnv: [],
+};

package/configs/jest/testing/mocks/axios.js

@@ -0,0 +1,15 @@
+export default {
+  defaults: {},
+  interceptors: {
+    request: {
+      use: jest.fn(),
+    },
+    response: {
+      use: jest.fn(),
+    },
+  },
+  create: jest.fn().mockReturnThis(),
+  get: jest.fn().mockResolvedValue({ data: {} }),
+  post: jest.fn().mockResolvedValue({ data: {} }),
+  put: jest.fn().mockResolvedValue({ data: {} }),
+};

package/configs/jest/testing/mocks/cssModule.js

@@ -0,0 +1 @@
+export default 'CSS_MODULE';

package/configs/jest/testing/mocks/frame.js

@@ -0,0 +1,2 @@
+export const filename = './frame.html';
+export default './frame.html';

package/configs/jest/testing/mocks/html.js

@@ -0,0 +1 @@
+export default 'HTML_MODULE';

package/configs/jest/testing/mocks/iframe.js

@@ -0,0 +1,2 @@
+export const filename = './iframe.html';
+export default './iframe.html';

package/configs/jest/testing/mocks/image.js

@@ -0,0 +1 @@
+export default 'IMAGE_MOCK';

package/configs/jest/testing/mocks/pui-app-loader.js

@@ -0,0 +1 @@
+export const load = () => {};

package/configs/jest/testing/mocks/pui-user-monitoring.js

@@ -0,0 +1,3 @@
+export const setCustomUserData = () => {};
+export const setCustomVirtualPageName = () => {};
+export const startVirtualPageMonitoringWithAutoEnd = () => {};

package/configs/jest/testing/mocks/retry-axios.js

@@ -0,0 +1,3 @@
+export const attach = jest.fn();
+export const detach = jest.fn();
+export const getConfig = jest.fn();

package/configs/jest/testing/mocks/svg.js

@@ -0,0 +1,2 @@
+export default 'SvgrURL';
+export const ReactComponent = 'div';

package/configs/jest/testing/mocks/webpack-hmr.js

@@ -0,0 +1 @@
+export const enableHotReloading = () => {};

package/configs/jest/testing/resolver.cjs

@@ -0,0 +1,43 @@
+const resolutions = [
+  {
+    matcher: /\.jsx?$/i,
+    extensions: ['.tsx', '.ts'],
+  },
+  {
+    matcher: /\.mjs$/i,
+    extensions: ['.mts'],
+  },
+  {
+    matcher: /\.cjs$/i,
+    extensions: ['.cts'],
+  },
+];
+
+const resolveConfig = {
+  conditionNames: ['import', 'node', 'default'],
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.json', '.node'],
+  modules: ['node_modules', 'app', 'lib'],
+};
+
+const importResolver = require('enhanced-resolve').create.sync(resolveConfig);
+const requireResolver = require('enhanced-resolve').create.sync({
+  ...resolveConfig,
+  conditionNames: ['require', 'node', 'default'],
+});
+
+module.exports = (request, options) => {
+  let resolver = requireResolver;
+  if (options.conditions?.includes('import')) {
+    resolver = importResolver;
+  }
+  const resolution = resolutions.find(({ matcher }) => matcher.test(request));
+  if (resolution) {
+    for (const extension of resolution.extensions) {
+      try {
+        return resolver(options.basedir, request.replace(resolution.matcher, extension));
+        // eslint-disable-next-line no-empty
+      } catch {}
+    }
+  }
+  return resolver(options.basedir, request);
+};

package/configs/jest/testing/setup-react-env.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-console */
+/* eslint-disable max-len */
+import * as React from 'react';
+import 'jest-styled-components';
+global.React = React;
+
+// @tanstack/react-virtual relies on DOM APIs that are not available in JSDOM
+//    Dimsum uses @tanstack/react-virtual for virtualized lists for performance
+// this mock ensure a standardized behavior for tests when dealing with virtualized lists:
+//  - parent size will be 500px height and 400px width regardless of the actual parent size
+//  - each item will be sized at 100px height regardless of the actual item size
+//  - overscan will be 15 items by default
+// which means any virtualized list in the "first" position will have 20 items rendered
+//    (15 overscan + 5 items in the viewport)
+try {
+  jest.mock('@tanstack/react-virtual', () => {
+    const original = jest.requireActual('@tanstack/react-virtual');
+    return {
+      ...original,
+      useVirtualizer: jest.fn((virtualOpts) => {
+        const finalOpts = {
+          ...virtualOpts,
+          overscan: 15,
+          initialRect: {
+            height: 500,
+            width: 400,
+          },
+          observeElementRect: (_, cb) => {
+            cb({ height: 500, width: 400 });
+          },
+          measureElement: () => 100,
+        };
+        return original.useVirtualizer(finalOpts);
+      }),
+    };
+  });
+} catch (e) {
+  console.log('Failed to mock @tanstack/react-virtual, test will operate without virtualization mocks');
+}
+// @tanstack/virtual-core relies on browser way to solve racing conditions to set targetWindow and scrollElement properly
+//   this mock tries to force default values to window and document.body respectively if something goes wrong racing condition wise
+//   all of the features on virtualization are heavely dependent on the specific browser way of operating and browser APIs
+//   so this mock may not cover all edge cases, but at least will avoid crashes due to missing window or document references
+//     and it will be as unreliable as testin browser specific features in JSDOM has always been.
+try {
+  jest.mock('@tanstack/virtual-core', () => {
+    const original = jest.requireActual('@tanstack/virtual-core');
+    return {
+      ...original,
+      Virtualizer: class MockedVirtualizer extends original.Virtualizer {
+        set targetWindow(value) {
+          this._targetWindow = value ?? window;
+        }
+
+        get targetWindow() {
+          return this._targetWindow ?? window;
+        }
+
+        set scrollElement(value) {
+          this._scrollElement = value ?? document.body;
+        }
+
+        get scrollElement() {
+          return this._scrollElement ?? document.body;
+        }
+
+        constructor(...opts) {
+          super(...opts);
+        }
+      },
+    };
+  });
+} catch (e) {
+  console.log(
+    'Failed to mock @tanstack/virtual-core, test will operate without virtualization mocks, it may fail due to missing window or document references',
+  );
+}

package/configs/jest/testing/setup-tests.js

@@ -0,0 +1,64 @@
+/* eslint-disable max-len */
+// needed for regenerator-runtime
+// (ES7 generator support is required by redux-saga)
+import 'regenerator-runtime/runtime';
+import { webcrypto } from 'node:crypto';
+// import 'core-js/stable'; // Generates a memory leak increasing tests memory consumption and execution time
+import '@testing-library/jest-dom/jest-globals';
+import jestAxe from 'jest-axe';
+import ResizeObserver from 'resize-observer-polyfill';
+
+Object.defineProperty(globalThis, 'crypto', {
+  value: webcrypto,
+});
+
+if (expect) expect.extend(jestAxe.toHaveNoViolations);
+
+const addElementToBody = (element) => {
+  const documentEle = (window || {}).document;
+  if (!documentEle) return null;
+  const bodyEle = documentEle.body;
+  const newEle = documentEle.createElement(...element);
+  if (!newEle) return null;
+  bodyEle.appendChild(newEle);
+  return newEle;
+};
+
+const addRootElement = (id) => {
+  const rootEle = addElementToBody('div');
+  if (rootEle) rootEle.id = id;
+};
+
+addRootElement('root');
+
+window.ResizeObserver = ResizeObserver;
+
+let showCorejsWarn = false;
+afterAll(() => {
+  if (showCorejsWarn) {
+    console.warn(
+      `IMPORTANT: Try importing core-js/stable in your failed test files and retrying.\nSome tests might have failed because of it`,
+    );
+  }
+});
+
+const originalTest = global.test;
+global.it = (name, fn, timeout = undefined) => {
+  const fnWrapper = async () => {
+    try {
+      await fn();
+    } catch (error) {
+      // Some tests require core-js/stable, so we retry on failed tests to ensure it didn't fail because of it
+      // We avoid importing by default in this setup because core-js/stable has a memory leak which increases memory consumption and tests execution times.
+      showCorejsWarn = true;
+      throw error;
+    }
+  };
+  originalTest(name, fnWrapper, timeout);
+};
+global.it.skip = originalTest.skip;
+global.it.only = originalTest.only;
+
+if (!global.performance.getEntriesByType) {
+  global.performance.getEntriesByType = jest.fn(() => []);
+}

package/configs/jest/testing/swcrc.config.cjs

@@ -0,0 +1,11 @@
+const fs = require('fs');
+const path = require('path');
+const { merge } = require('lodash');
+
+let projectConfig = {};
+const projectPath = path.join(process.cwd(), '.swcrc');
+if (fs.existsSync(projectPath)) {
+  projectConfig = JSON.parse(fs.readFileSync(projectPath, 'utf-8'));
+}
+const localConfig = JSON.parse(fs.readFileSync(path.join(__dirname, '.swcrc'), 'utf-8'));
+exports.swcrcConfig = merge(localConfig, projectConfig);

package/configs/jest/testing/utils.cjs

@@ -0,0 +1,30 @@
+const path = require('path');
+const WORKSPACE_DIR_ENV_VAR = 'NPM_CONFIG_WORKSPACE_DIR';
+const WORKSPACE_MANIFEST_FILENAME = 'pnpm-workspace.yaml';
+
+const getPNPMWorkspaceLocation = (cwd) => {
+  const root = path.parse(cwd).root;
+  let currentDir = cwd;
+
+  while (currentDir && currentDir !== root) {
+    // Check for workspace manifest files
+    for (const fileName of [WORKSPACE_MANIFEST_FILENAME, 'pnpm-workspace.yml']) {
+      const filePath = path.join(currentDir, fileName);
+      // eslint-disable-next-line no-undef
+      if (require('fs').existsSync(filePath)) {
+        return filePath;
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+};
+
+exports.findMonoRepoRoot = (cwd = process.cwd()) => {
+  const workspaceManifestDirEnvVar =
+    process.env[WORKSPACE_DIR_ENV_VAR] ?? process.env[WORKSPACE_DIR_ENV_VAR.toLowerCase()];
+  const workspaceManifestLocation = workspaceManifestDirEnvVar
+    ? path.join(workspaceManifestDirEnvVar, 'pnpm-workspace.yaml')
+    : getPNPMWorkspaceLocation(cwd);
+  return workspaceManifestLocation && path.dirname(workspaceManifestLocation);
+};

package/configs/playwright/playwright-component-testing-config.mjs

@@ -18,9 +18,9 @@ export const config = defineConfig({
   // ctViteConfig: viteDefineConfig({ logLevel: 'info', plugins: [react()] }),
   use: {
     ctPort: 31500,
-    headless: process.env.CI ? true : false,
+    headless: process.env.CI || process.env.PW_HEADLESS ? true : false,
     launchOptions: {
-      devtools: process.env.CI ? false : true,
+      devtools: process.env.CI || process.env.PW_HEADLESS ? false : true,
     },
   },
   projects: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-monorepo-devops",
-  "version": "3.60.0-next.5",
+  "version": "3.60.0-next.50",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Monorepo Devops",
   "type": "module",
@@ -42,21 +42,58 @@
     "reportFile": "tests.xml",
     "indent": 4
   },
-  "scripts": {},
   "peerDependencies": {
-    "@elliemae/pui-cli": "catalog:",
+    "@swc/core": "~1.13.5",
+    "@swc/jest": "~0.2.39",
+    "@testing-library/dom": "~10.4.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.0.1",
+    "@testing-library/react-hooks": "~8.0.1",
+    "@testing-library/user-event": "~14.6.1",
     "arg": "~5.0.2",
-    "glob": "~10.2.5",
-    "ignore": "^5.3.0",
-    "inquirer": "~12.0.0",
-    "jest": "catalog:"
+    "find-up": "~8.0.0",
+    "find-up-cli": "~6.0.0",
+    "glob": "~13.0.0",
+    "ignore": "~7.0.5",
+    "inquirer": "~13.2.0",
+    "jest": "^30.0.0",
+    "jest-environment-jsdom": "^30.0.0",
+    "jest-fixed-jsdom": "~0.0.11",
+    "jest-sonar-reporter": "~2.0.0",
+    "jest-watch-typeahead": "~3.0.1",
+    "normalize-path": "~3.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@swc/core": "~1.13.5",
+    "@swc/jest": "~0.2.39",
+    "@testing-library/dom": "~10.4.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.0.1",
+    "@testing-library/react-hooks": "~8.0.1",
+    "@testing-library/user-event": "~14.6.1",
+    "arg": "~5.0.2",
+    "find-up": "~8.0.0",
+    "find-up-cli": "~6.0.0",
+    "glob": "~13.0.0",
+    "ignore": "~7.0.5",
+    "inquirer": "~13.2.0",
+    "jest": "^30.0.0",
+    "jest-environment-jsdom": "^30.0.0",
+    "jest-fixed-jsdom": "~0.0.11",
+    "jest-sonar-reporter": "~2.0.0",
+    "jest-watch-typeahead": "~3.0.1",
+    "normalize-path": "~3.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "publishConfig": {
     "access": "public",
     "typeSafety": false
   },
   "dependencies": {
-    "@playwright/experimental-ct-react": "catalog:"
+    "@playwright/experimental-ct-react": "^1.51.1"
   },
-  "gitHead": "2c3d9fa1d09e130b4e5f43d9f817c96e10709182"
-}
+  "scripts": {}
+}

package/configs/jest/virtualListFix.mjs

@@ -1,21 +0,0 @@
-jest.mock('@tanstack/react-virtual', () => {
-  const original = jest.requireActual('@tanstack/react-virtual');
-  return {
-    ...original,
-    useVirtualizer: jest.fn((virtualOpts) => {
-      const finalOpts = {
-        ...virtualOpts,
-        overscan: 15,
-        initialRect: {
-          height: 500,
-          width: 400,
-        },
-        observeElementRect: (_, cb) => {
-          cb({ height: 500, width: 400 });
-        },
-        measureElement: () => 100,
-      };
-      return original.useVirtualizer(finalOpts);
-    }),
-  };
-});