cargdev/reactwizard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: initial commit

Browse Source
This commit is contained in:
Carlos
2024-08-12 22:57:35 -04:00
commit 6f68ae8259
13140 changed files with 1104801 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
node_modules/jest-cli/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) Meta Platforms, Inc. and affiliates.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

11
node_modules/jest-cli/README.md generated vendored Normal file
View File

@ -0,0 +1,11 @@
# Jest
🃏 Delightful JavaScript Testing
- **👩🏻‍💻 Developer Ready**: Complete and ready to set-up JavaScript testing solution. Works out of the box for any React project.
- **🏃🏽 Instant Feedback**: Failed tests run first. Fast interactive mode can switch between running all tests or only test files related to changed files.
- **📸 Snapshot Testing**: Jest can [capture snapshots](https://jestjs.io/docs/snapshot-testing) of React trees or other serializable values to simplify UI testing.
Read More: https://jestjs.io/

17
node_modules/jest-cli/bin/jest.js generated vendored Executable file
View File

@ -0,0 +1,17 @@
#!/usr/bin/env node
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
const importLocal = require('import-local');
if (!importLocal(__filename)) {
if (process.env.NODE_ENV == null) {
process.env.NODE_ENV = 'test';
}
require('..').run();
}

731
node_modules/jest-cli/build/args.js generated vendored Normal file
View File

@ -0,0 +1,731 @@
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.check = check;
exports.usage = exports.options = exports.docs = void 0;
function _jestConfig() {
const data = require('jest-config');
_jestConfig = function () {
return data;
};
return data;
}
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
function check(argv) {
if (
argv.runInBand &&
Object.prototype.hasOwnProperty.call(argv, 'maxWorkers')
) {
throw new Error(
'Both --runInBand and --maxWorkers were specified, only one is allowed.'
);
}
for (const key of [
'onlyChanged',
'lastCommit',
'changedFilesWithAncestor',
'changedSince'
]) {
if (argv[key] && argv.watchAll) {
throw new Error(
`Both --${key} and --watchAll were specified, but cannot be used ` +
'together. Try the --watch option which reruns only tests ' +
'related to changed files.'
);
}
}
if (argv.onlyFailures && argv.watchAll) {
throw new Error(
'Both --onlyFailures and --watchAll were specified, only one is allowed.'
);
}
if (argv.findRelatedTests && argv._.length === 0) {
throw new Error(
'The --findRelatedTests option requires file paths to be specified.\n' +
'Example usage: jest --findRelatedTests ./src/source.js ' +
'./src/index.js.'
);
}
if (
Object.prototype.hasOwnProperty.call(argv, 'maxWorkers') &&
argv.maxWorkers === undefined
) {
throw new Error(
'The --maxWorkers (-w) option requires a number or string to be specified.\n' +
'Example usage: jest --maxWorkers 2\n' +
'Example usage: jest --maxWorkers 50%\n' +
'Or did you mean --watch?'
);
}
if (argv.selectProjects && argv.selectProjects.length === 0) {
throw new Error(
'The --selectProjects option requires the name of at least one project to be specified.\n' +
'Example usage: jest --selectProjects my-first-project my-second-project'
);
}
if (argv.ignoreProjects && argv.ignoreProjects.length === 0) {
throw new Error(
'The --ignoreProjects option requires the name of at least one project to be specified.\n' +
'Example usage: jest --ignoreProjects my-first-project my-second-project'
);
}
if (
argv.config &&
!(0, _jestConfig().isJSONString)(argv.config) &&
!argv.config.match(
new RegExp(
`\\.(${_jestConfig()
.constants.JEST_CONFIG_EXT_ORDER.map(e => e.substring(1))
.join('|')})$`,
'i'
)
)
) {
throw new Error(
`The --config option requires a JSON string literal, or a file path with one of these extensions: ${_jestConfig().constants.JEST_CONFIG_EXT_ORDER.join(
', '
)}.\nExample usage: jest --config ./jest.config.js`
);
}
return true;
}
const usage = 'Usage: $0 [--config=<pathToConfigFile>] [TestPathPattern]';
exports.usage = usage;
const docs = 'Documentation: https://jestjs.io/';
// The default values are all set in jest-config
exports.docs = docs;
const options = {
all: {
description:
'The opposite of `onlyChanged`. If `onlyChanged` is set by ' +
'default, running jest with `--all` will force Jest to run all tests ' +
'instead of running only tests related to changed files.',
type: 'boolean'
},
automock: {
description: 'Automock all files by default.',
type: 'boolean'
},
bail: {
alias: 'b',
description:
'Exit the test suite immediately after `n` number of failing tests.',
type: 'boolean'
},
cache: {
description:
'Whether to use the transform cache. Disable the cache ' +
'using --no-cache.',
type: 'boolean'
},
cacheDirectory: {
description:
'The directory where Jest should store its cached ' +
' dependency information.',
type: 'string'
},
changedFilesWithAncestor: {
description:
'Runs tests related to the current changes and the changes made in the ' +
'last commit. Behaves similarly to `--onlyChanged`.',
type: 'boolean'
},
changedSince: {
description:
'Runs tests related to the changes since the provided branch. If the ' +
'current branch has diverged from the given branch, then only changes ' +
'made locally will be tested. Behaves similarly to `--onlyChanged`.',
nargs: 1,
type: 'string'
},
ci: {
description:
'Whether to run Jest in continuous integration (CI) mode. ' +
'This option is on by default in most popular CI environments. It will ' +
'prevent snapshots from being written unless explicitly requested.',
type: 'boolean'
},
clearCache: {
description:
'Clears the configured Jest cache directory and then exits. ' +
'Default directory can be found by calling jest --showConfig',
type: 'boolean'
},
clearMocks: {
description:
'Automatically clear mock calls, instances, contexts and results before every test. ' +
'Equivalent to calling jest.clearAllMocks() before each test.',
type: 'boolean'
},
collectCoverage: {
description: 'Alias for --coverage.',
type: 'boolean'
},
collectCoverageFrom: {
description:
'A glob pattern relative to <rootDir> matching the files that coverage ' +
'info needs to be collected from.',
type: 'string'
},
color: {
description:
'Forces test results output color highlighting (even if ' +
'stdout is not a TTY). Set to false if you would like to have no colors.',
type: 'boolean'
},
colors: {
description: 'Alias for `--color`.',
type: 'boolean'
},
config: {
alias: 'c',
description:
'The path to a jest config file specifying how to find ' +
'and execute tests. If no rootDir is set in the config, the directory ' +
'containing the config file is assumed to be the rootDir for the project. ' +
'This can also be a JSON encoded value which Jest will use as configuration.',
type: 'string'
},
coverage: {
description:
'Indicates that test coverage information should be ' +
'collected and reported in the output.',
type: 'boolean'
},
coverageDirectory: {
description: 'The directory where Jest should output its coverage files.',
type: 'string'
},
coveragePathIgnorePatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all file paths before executing the test. If the file path ' +
'matches any of the patterns, coverage information will be skipped.',
string: true,
type: 'array'
},
coverageProvider: {
choices: ['babel', 'v8'],
description: 'Select between Babel and V8 to collect coverage'
},
coverageReporters: {
description:
'A list of reporter names that Jest uses when writing ' +
'coverage reports. Any istanbul reporter can be used.',
string: true,
type: 'array'
},
coverageThreshold: {
description:
'A JSON string with which will be used to configure ' +
'minimum threshold enforcement for coverage results',
type: 'string'
},
debug: {
description: 'Print debugging info about your jest config.',
type: 'boolean'
},
detectLeaks: {
description:
'**EXPERIMENTAL**: Detect memory leaks in tests. After executing a ' +
'test, it will try to garbage collect the global object used, and fail ' +
'if it was leaked',
type: 'boolean'
},
detectOpenHandles: {
description:
'Print out remaining open handles preventing Jest from exiting at the ' +
'end of a test run. Implies `runInBand`.',
type: 'boolean'
},
env: {
description:
'The test environment used for all tests. This can point to ' +
'any file or node module. Examples: `jsdom`, `node` or ' +
'`path/to/my-environment.js`',
type: 'string'
},
errorOnDeprecated: {
description: 'Make calling deprecated APIs throw helpful error messages.',
type: 'boolean'
},
expand: {
alias: 'e',
description: 'Use this flag to show full diffs instead of a patch.',
type: 'boolean'
},
filter: {
description:
'Path to a module exporting a filtering function. This method receives ' +
'a list of tests which can be manipulated to exclude tests from ' +
'running. Especially useful when used in conjunction with a testing ' +
'infrastructure to filter known broken tests.',
type: 'string'
},
findRelatedTests: {
description:
'Find related tests for a list of source files that were ' +
'passed in as arguments. Useful for pre-commit hook integration to run ' +
'the minimal amount of tests necessary.',
type: 'boolean'
},
forceExit: {
description:
'Force Jest to exit after all tests have completed running. ' +
'This is useful when resources set up by test code cannot be ' +
'adequately cleaned up.',
type: 'boolean'
},
globalSetup: {
description: 'The path to a module that runs before All Tests.',
type: 'string'
},
globalTeardown: {
description: 'The path to a module that runs after All Tests.',
type: 'string'
},
globals: {
description:
'A JSON string with map of global variables that need ' +
'to be available in all test environments.',
type: 'string'
},
haste: {
description:
'A JSON string with map of variables for the haste module system',
type: 'string'
},
ignoreProjects: {
description:
'Ignore the tests of the specified projects. ' +
'Jest uses the attribute `displayName` in the configuration to identify each project.',
string: true,
type: 'array'
},
init: {
description: 'Generate a basic configuration file',
type: 'boolean'
},
injectGlobals: {
description: 'Should Jest inject global variables or not',
type: 'boolean'
},
json: {
description:
'Prints the test results in JSON. This mode will send all ' +
'other test output and user messages to stderr.',
type: 'boolean'
},
lastCommit: {
description:
'Run all tests affected by file changes in the last commit made. ' +
'Behaves similarly to `--onlyChanged`.',
type: 'boolean'
},
listTests: {
description:
'Lists all tests Jest will run given the arguments and ' +
'exits. Most useful in a CI system together with `--findRelatedTests` ' +
'to determine the tests Jest will run based on specific files',
type: 'boolean'
},
logHeapUsage: {
description:
'Logs the heap usage after every test. Useful to debug ' +
'memory leaks. Use together with `--runInBand` and `--expose-gc` in ' +
'node.',
type: 'boolean'
},
maxConcurrency: {
description:
'Specifies the maximum number of tests that are allowed to run ' +
'concurrently. This only affects tests using `test.concurrent`.',
type: 'number'
},
maxWorkers: {
alias: 'w',
description:
'Specifies the maximum number of workers the worker-pool ' +
'will spawn for running tests. This defaults to the number of the ' +
'cores available on your machine. (its usually best not to override ' +
'this default)',
type: 'string'
},
moduleDirectories: {
description:
'An array of directory names to be searched recursively ' +
"up from the requiring module's location.",
string: true,
type: 'array'
},
moduleFileExtensions: {
description:
'An array of file extensions your modules use. If you ' +
'require modules without specifying a file extension, these are the ' +
'extensions Jest will look for.',
string: true,
type: 'array'
},
moduleNameMapper: {
description:
'A JSON string with a map from regular expressions to ' +
'module names or to arrays of module names that allow to stub ' +
'out resources, like images or styles with a single module',
type: 'string'
},
modulePathIgnorePatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all module paths before those paths are to be considered ' +
'"visible" to the module loader.',
string: true,
type: 'array'
},
modulePaths: {
description:
'An alternative API to setting the NODE_PATH env variable, ' +
'modulePaths is an array of absolute paths to additional locations to ' +
'search when resolving modules.',
string: true,
type: 'array'
},
noStackTrace: {
description: 'Disables stack trace in test results output',
type: 'boolean'
},
notify: {
description: 'Activates notifications for test results.',
type: 'boolean'
},
notifyMode: {
description: 'Specifies when notifications will appear for test results.',
type: 'string'
},
onlyChanged: {
alias: 'o',
description:
'Attempts to identify which tests to run based on which ' +
"files have changed in the current repository. Only works if you're " +
'running tests in a git or hg repository at the moment.',
type: 'boolean'
},
onlyFailures: {
alias: 'f',
description: 'Run tests that failed in the previous execution.',
type: 'boolean'
},
openHandlesTimeout: {
description:
'Print a warning about probable open handles if Jest does not exit ' +
'cleanly after this number of milliseconds. `0` to disable.',
type: 'number'
},
outputFile: {
description:
'Write test results to a file when the --json option is ' +
'also specified.',
type: 'string'
},
passWithNoTests: {
description:
'Will not fail if no tests are found (for example while using `--testPathPattern`.)',
type: 'boolean'
},
preset: {
description: "A preset that is used as a base for Jest's configuration.",
type: 'string'
},
prettierPath: {
description: 'The path to the "prettier" module used for inline snapshots.',
type: 'string'
},
projects: {
description:
'A list of projects that use Jest to run all tests of all ' +
'projects in a single instance of Jest.',
string: true,
type: 'array'
},
randomize: {
description:
'Shuffle the order of the tests within a file. In order to choose the seed refer to the `--seed` CLI option.',
type: 'boolean'
},
reporters: {
description: 'A list of custom reporters for the test suite.',
string: true,
type: 'array'
},
resetMocks: {
description:
'Automatically reset mock state before every test. ' +
'Equivalent to calling jest.resetAllMocks() before each test.',
type: 'boolean'
},
resetModules: {
description:
'If enabled, the module registry for every test file will ' +
'be reset before running each individual test.',
type: 'boolean'
},
resolver: {
description: 'A JSON string which allows the use of a custom resolver.',
type: 'string'
},
restoreMocks: {
description:
'Automatically restore mock state and implementation before every test. ' +
'Equivalent to calling jest.restoreAllMocks() before each test.',
type: 'boolean'
},
rootDir: {
description:
'The root directory that Jest should scan for tests and ' +
'modules within.',
type: 'string'
},
roots: {
description:
'A list of paths to directories that Jest should use to ' +
'search for files in.',
string: true,
type: 'array'
},
runInBand: {
alias: 'i',
description:
'Run all tests serially in the current process (rather than ' +
'creating a worker pool of child processes that run tests). This ' +
'is sometimes useful for debugging, but such use cases are pretty ' +
'rare.',
type: 'boolean'
},
runTestsByPath: {
description:
'Used when provided patterns are exact file paths. This avoids ' +
'converting them into a regular expression and matching it against ' +
'every single file.',
type: 'boolean'
},
runner: {
description:
"Allows to use a custom runner instead of Jest's default test runner.",
type: 'string'
},
seed: {
description:
'Sets a seed value that can be retrieved in a tests file via `jest.getSeed()`. If this option is not specified Jest will randomly generate the value. The seed value must be between `-0x80000000` and `0x7fffffff` inclusive.',
type: 'number'
},
selectProjects: {
description:
'Run the tests of the specified projects. ' +
'Jest uses the attribute `displayName` in the configuration to identify each project.',
string: true,
type: 'array'
},
setupFiles: {
description:
'A list of paths to modules that run some code to configure or ' +
'set up the testing environment before each test.',
string: true,
type: 'array'
},
setupFilesAfterEnv: {
description:
'A list of paths to modules that run some code to configure or ' +
'set up the testing framework before each test',
string: true,
type: 'array'
},
shard: {
description:
'Shard tests and execute only the selected shard, specify in ' +
'the form "current/all". 1-based, for example "3/5".',
type: 'string'
},
showConfig: {
description: 'Print your jest config and then exits.',
type: 'boolean'
},
showSeed: {
description:
'Prints the seed value in the test report summary. See `--seed` for how to set this value',
type: 'boolean'
},
silent: {
description: 'Prevent tests from printing messages through the console.',
type: 'boolean'
},
skipFilter: {
description:
'Disables the filter provided by --filter. Useful for CI jobs, or ' +
'local enforcement when fixing tests.',
type: 'boolean'
},
snapshotSerializers: {
description:
'A list of paths to snapshot serializer modules Jest should ' +
'use for snapshot testing.',
string: true,
type: 'array'
},
testEnvironment: {
description: 'Alias for --env',
type: 'string'
},
testEnvironmentOptions: {
description:
'A JSON string with options that will be passed to the `testEnvironment`. ' +
'The relevant options depend on the environment.',
type: 'string'
},
testFailureExitCode: {
description: 'Exit code of `jest` command if the test run failed',
type: 'string' // number
},
testLocationInResults: {
description: 'Add `location` information to the test results',
type: 'boolean'
},
testMatch: {
description: 'The glob patterns Jest uses to detect test files.',
string: true,
type: 'array'
},
testNamePattern: {
alias: 't',
description: 'Run only tests with a name that matches the regex pattern.',
type: 'string'
},
testPathIgnorePatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all test paths before executing the test. If the test path ' +
'matches any of the patterns, it will be skipped.',
string: true,
type: 'array'
},
testPathPattern: {
description:
'A regexp pattern string that is matched against all tests ' +
'paths before executing the test.',
string: true,
type: 'array'
},
testRegex: {
description:
'A string or array of string regexp patterns that Jest uses to detect test files.',
string: true,
type: 'array'
},
testResultsProcessor: {
description:
'Allows the use of a custom results processor. ' +
'This processor must be a node module that exports ' +
'a function expecting as the first argument the result object.',
type: 'string'
},
testRunner: {
description:
'Allows to specify a custom test runner. The default is' +
' `jest-circus/runner`. A path to a custom test runner can be provided:' +
' `<rootDir>/path/to/testRunner.js`.',
type: 'string'
},
testSequencer: {
description:
'Allows to specify a custom test sequencer. The default is ' +
'`@jest/test-sequencer`. A path to a custom test sequencer can be ' +
'provided: `<rootDir>/path/to/testSequencer.js`',
type: 'string'
},
testTimeout: {
description: 'This option sets the default timeouts of test cases.',
type: 'number'
},
transform: {
description:
'A JSON string which maps from regular expressions to paths ' +
'to transformers.',
type: 'string'
},
transformIgnorePatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all source file paths before transformation.',
string: true,
type: 'array'
},
unmockedModulePathPatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all modules before the module loader will automatically ' +
'return a mock for them.',
string: true,
type: 'array'
},
updateSnapshot: {
alias: 'u',
description:
'Use this flag to re-record snapshots. ' +
'Can be used together with a test suite pattern or with ' +
'`--testNamePattern` to re-record snapshot for test matching ' +
'the pattern',
type: 'boolean'
},
useStderr: {
description: 'Divert all output to stderr.',
type: 'boolean'
},
verbose: {
description:
'Display individual test results with the test suite hierarchy.',
type: 'boolean'
},
watch: {
description:
'Watch files for changes and rerun tests related to ' +
'changed files. If you want to re-run all tests when a file has ' +
'changed, use the `--watchAll` option.',
type: 'boolean'
},
watchAll: {
description:
'Watch files for changes and rerun all tests. If you want ' +
'to re-run only the tests related to the changed files, use the ' +
'`--watch` option.',
type: 'boolean'
},
watchPathIgnorePatterns: {
description:
'An array of regexp pattern strings that are matched ' +
'against all paths before trigger test re-run in watch mode. ' +
'If the test path matches any of the patterns, it will be skipped.',
string: true,
type: 'array'
},
watchman: {
description:
'Whether to use watchman for file crawling. Disable using ' +
'--no-watchman.',
type: 'boolean'
},
workerThreads: {
description:
'Whether to use worker threads for parallelization. Child processes ' +
'are used by default.',
type: 'boolean'
}
};
exports.options = options;

18
node_modules/jest-cli/build/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,18 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import type {Options} from 'yargs';
export declare function run(
maybeArgv?: Array<string>,
project?: string,
): Promise<void>;
export declare const yargsOptions: {
[key: string]: Options;
};
export {};

19
node_modules/jest-cli/build/index.js generated vendored Normal file
View File

@ -0,0 +1,19 @@
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
Object.defineProperty(exports, 'run', {
enumerable: true,
get: function () {
return _run.run;
}
});
Object.defineProperty(exports, 'yargsOptions', {
enumerable: true,
get: function () {
return _args.options;
}
});
var _run = require('./run');
var _args = require('./args');

239
node_modules/jest-cli/build/run.js generated vendored Normal file
View File

@ -0,0 +1,239 @@
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.buildArgv = buildArgv;
exports.run = run;
function path() {
const data = _interopRequireWildcard(require('path'));
path = function () {
return data;
};
return data;
}
function _chalk() {
const data = _interopRequireDefault(require('chalk'));
_chalk = function () {
return data;
};
return data;
}
function _exit() {
const data = _interopRequireDefault(require('exit'));
_exit = function () {
return data;
};
return data;
}
function _yargs() {
const data = _interopRequireDefault(require('yargs'));
_yargs = function () {
return data;
};
return data;
}
function _core() {
const data = require('@jest/core');
_core = function () {
return data;
};
return data;
}
function _createJest() {
const data = require('create-jest');
_createJest = function () {
return data;
};
return data;
}
function _jestConfig() {
const data = require('jest-config');
_jestConfig = function () {
return data;
};
return data;
}
function _jestUtil() {
const data = require('jest-util');
_jestUtil = function () {
return data;
};
return data;
}
function _jestValidate() {
const data = require('jest-validate');
_jestValidate = function () {
return data;
};
return data;
}
var args = _interopRequireWildcard(require('./args'));
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {default: obj};
}
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== 'function') return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function (nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interopRequireWildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
return {default: obj};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {};
var hasPropertyDescriptor =
Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var key in obj) {
if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor
? Object.getOwnPropertyDescriptor(obj, key)
: null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
async function run(maybeArgv, project) {
try {
const argv = await buildArgv(maybeArgv);
if (argv.init) {
await (0, _createJest().runCreate)();
return;
}
const projects = getProjectListFromCLIArgs(argv, project);
const {results, globalConfig} = await (0, _core().runCLI)(argv, projects);
readResultsAndExit(results, globalConfig);
} catch (error) {
(0, _jestUtil().clearLine)(process.stderr);
(0, _jestUtil().clearLine)(process.stdout);
if (error?.stack) {
console.error(_chalk().default.red(error.stack));
} else {
console.error(_chalk().default.red(error));
}
(0, _exit().default)(1);
throw error;
}
}
async function buildArgv(maybeArgv) {
const version =
(0, _core().getVersion)() +
(__dirname.includes(`packages${path().sep}jest-cli`) ? '-dev' : '');
const rawArgv = maybeArgv || process.argv.slice(2);
const argv = await (0, _yargs().default)(rawArgv)
.usage(args.usage)
.version(version)
.alias('help', 'h')
.options(args.options)
.epilogue(args.docs)
.check(args.check).argv;
(0, _jestValidate().validateCLIOptions)(
argv,
{
...args.options,
deprecationEntries: _jestConfig().deprecationEntries
},
// strip leading dashes
Array.isArray(rawArgv)
? rawArgv.map(rawArgv => rawArgv.replace(/^--?/, ''))
: Object.keys(rawArgv)
);
// strip dashed args
return Object.keys(argv).reduce(
(result, key) => {
if (!key.includes('-')) {
result[key] = argv[key];
}
return result;
},
{
$0: argv.$0,
_: argv._
}
);
}
const getProjectListFromCLIArgs = (argv, project) => {
const projects = argv.projects ? argv.projects : [];
if (project) {
projects.push(project);
}
if (!projects.length && process.platform === 'win32') {
try {
projects.push((0, _jestUtil().tryRealpath)(process.cwd()));
} catch {
// do nothing, just catch error
// process.binding('fs').realpath can throw, e.g. on mapped drives
}
}
if (!projects.length) {
projects.push(process.cwd());
}
return projects;
};
const readResultsAndExit = (result, globalConfig) => {
const code = !result || result.success ? 0 : globalConfig.testFailureExitCode;
// Only exit if needed
process.on('exit', () => {
if (typeof code === 'number' && code !== 0) {
process.exitCode = code;
}
});
if (globalConfig.forceExit) {
if (!globalConfig.detectOpenHandles) {
console.warn(
`${_chalk().default.bold(
'Force exiting Jest: '
)}Have you considered using \`--detectOpenHandles\` to detect ` +
'async operations that kept running after all tests finished?'
);
}
(0, _exit().default)(code);
} else if (
!globalConfig.detectOpenHandles &&
globalConfig.openHandlesTimeout !== 0
) {
const timeout = globalConfig.openHandlesTimeout;
setTimeout(() => {
console.warn(
_chalk().default.yellow.bold(
`Jest did not exit ${
timeout === 1000 ? 'one second' : `${timeout / 1000} seconds`
} after the test run has completed.\n\n'`
) +
_chalk().default.yellow(
'This usually means that there are asynchronous operations that ' +
"weren't stopped in your tests. Consider running Jest with " +
'`--detectOpenHandles` to troubleshoot this issue.'
)
);
}, timeout).unref();
}
};

88
node_modules/jest-cli/package.json generated vendored Normal file
View File

@ -0,0 +1,88 @@
{
"name": "jest-cli",
"description": "Delightful JavaScript Testing.",
"version": "29.7.0",
"main": "./build/index.js",
"types": "./build/index.d.ts",
"exports": {
".": {
"types": "./build/index.d.ts",
"default": "./build/index.js"
},
"./package.json": "./package.json",
"./bin/jest": "./bin/jest.js"
},
"dependencies": {
"@jest/core": "^29.7.0",
"@jest/test-result": "^29.7.0",
"@jest/types": "^29.6.3",
"chalk": "^4.0.0",
"create-jest": "^29.7.0",
"exit": "^0.1.2",
"import-local": "^3.0.2",
"jest-config": "^29.7.0",
"jest-util": "^29.7.0",
"jest-validate": "^29.7.0",
"yargs": "^17.3.1"
},
"devDependencies": {
"@tsd/typescript": "^5.0.4",
"@types/exit": "^0.1.30",
"@types/yargs": "^17.0.8",
"tsd-lite": "^0.7.0"
},
"peerDependencies": {
"node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
},
"peerDependenciesMeta": {
"node-notifier": {
"optional": true
}
},
"bin": {
"jest": "./bin/jest.js"
},
"engines": {
"node": "^14.15.0 || ^16.10.0 || >=18.0.0"
},
"repository": {
"type": "git",
"url": "https://github.com/jestjs/jest.git",
"directory": "packages/jest-cli"
},
"bugs": {
"url": "https://github.com/jestjs/jest/issues"
},
"homepage": "https://jestjs.io/",
"license": "MIT",
"keywords": [
"ava",
"babel",
"coverage",
"easy",
"expect",
"facebook",
"immersive",
"instant",
"jasmine",
"jest",
"jsdom",
"mocha",
"mocking",
"painless",
"qunit",
"runner",
"sandboxed",
"snapshot",
"tap",
"tape",
"test",
"testing",
"typescript",
"watch"
],
"publishConfig": {
"access": "public"
},
"gitHead": "4e56991693da7cd4c3730dc3579a1dd1403ee630"
}