@nx/eslint 24.0.6 → 24.1.0-beta.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/src/generators/utils/eslint-file.d.ts +1 -0
- package/dist/src/generators/utils/eslint-file.js +4 -3
- package/dist/src/generators/utils/flat-config/ast-utils.d.ts +2 -0
- package/dist/src/generators/utils/flat-config/ast-utils.js +2 -0
- package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md +4 -0
- package/dist/src/migrations/update-24-1-0/add-directive-checks-rule.d.ts +2 -0
- package/dist/src/migrations/update-24-1-0/add-directive-checks-rule.js +193 -0
- package/dist/src/migrations/update-24-1-0/add-directive-checks-rule.md +49 -0
- package/migrations.json +6 -0
- package/package.json +5 -5
|
@@ -2,6 +2,7 @@ import { type GeneratorCallback, type Tree } from '@nx/devkit';
|
|
|
2
2
|
import type { Linter } from 'eslint';
|
|
3
3
|
export declare function findEslintFile(tree: Tree, projectRoot?: string): string | null;
|
|
4
4
|
export declare function isEslintConfigSupported(tree: Tree, projectRoot?: string): boolean;
|
|
5
|
+
export declare function isEslintConfigFileSupported(eslintFile: string): boolean;
|
|
5
6
|
export declare function updateRelativePathsInConfig(tree: Tree, sourcePath: string, destinationPath: string): void;
|
|
6
7
|
export declare function determineEslintConfigFormat(content: string): 'mjs' | 'cjs';
|
|
7
8
|
/**
|
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
3
|
exports.findEslintFile = findEslintFile;
|
|
4
4
|
exports.isEslintConfigSupported = isEslintConfigSupported;
|
|
5
|
+
exports.isEslintConfigFileSupported = isEslintConfigFileSupported;
|
|
5
6
|
exports.updateRelativePathsInConfig = updateRelativePathsInConfig;
|
|
6
7
|
exports.determineEslintConfigFormat = determineEslintConfigFormat;
|
|
7
8
|
exports.isTypedLintingEnabled = isTypedLintingEnabled;
|
|
@@ -45,9 +46,9 @@ function findEslintFile(tree, projectRoot) {
|
|
|
45
46
|
}
|
|
46
47
|
function isEslintConfigSupported(tree, projectRoot = '') {
|
|
47
48
|
const eslintFile = findEslintFile(tree, projectRoot);
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
49
|
+
return !!eslintFile && isEslintConfigFileSupported(eslintFile);
|
|
50
|
+
}
|
|
51
|
+
function isEslintConfigFileSupported(eslintFile) {
|
|
51
52
|
return (eslintFile.endsWith('.json') ||
|
|
52
53
|
eslintFile.endsWith('.config.js') ||
|
|
53
54
|
eslintFile.endsWith('.config.cjs') ||
|
|
@@ -4,6 +4,8 @@ import * as ts from 'typescript';
|
|
|
4
4
|
* Remove all overrides from the config file
|
|
5
5
|
*/
|
|
6
6
|
export declare function removeOverridesFromLintConfig(content: string): string;
|
|
7
|
+
export declare function findExportDefault(source: ts.SourceFile): ts.NodeArray<ts.Node>;
|
|
8
|
+
export declare function findModuleExports(source: ts.SourceFile): ts.NodeArray<ts.Node>;
|
|
7
9
|
export declare function addPatternsToFlatConfigIgnoresBlock(content: string, ignorePatterns: string[]): string;
|
|
8
10
|
export declare function hasFlatConfigIgnoresBlock(content: string): boolean;
|
|
9
11
|
export declare function hasOverride(content: string, lookup: (override: Linter.ConfigOverride<Linter.RulesRecord>) => boolean): boolean;
|
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
3
|
exports.removeOverridesFromLintConfig = removeOverridesFromLintConfig;
|
|
4
|
+
exports.findExportDefault = findExportDefault;
|
|
5
|
+
exports.findModuleExports = findModuleExports;
|
|
4
6
|
exports.addPatternsToFlatConfigIgnoresBlock = addPatternsToFlatConfigIgnoresBlock;
|
|
5
7
|
exports.hasFlatConfigIgnoresBlock = hasFlatConfigIgnoresBlock;
|
|
6
8
|
exports.hasOverride = hasOverride;
|
|
@@ -4,6 +4,10 @@ Nx 24 removes the `@nx/eslint:lint` executor and its `@nrwl/linter:eslint` alias
|
|
|
4
4
|
|
|
5
5
|
The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
|
|
6
6
|
|
|
7
|
+
The inferred task passes its options and command-line flags to the ESLint CLI, which only accepts kebab-case names such as `--max-warnings`, `--output-file`, and `--format`. The migration renames options in project configuration, except options set to `0`, `false`, or an empty string, such as `maxWarnings: 0`. Rename those by hand, and update scripts and CI commands that pass `--maxWarnings` or `--outputFile` to the ESLint names.
|
|
8
|
+
|
|
9
|
+
The inferred task also runs ESLint from the project root instead of the workspace root, so in legacy eslintrc mode a `.eslintignore` at the workspace root no longer applies. See [Troubleshoot convert-to-inferred](https://nx.dev/docs/kb/troubleshoot-convert-to-inferred#eslint-and-vitest-tasks-run-from-the-project-root) for how to handle it.
|
|
10
|
+
|
|
7
11
|
#### Sample code changes
|
|
8
12
|
|
|
9
13
|
##### Before
|
|
@@ -0,0 +1,193 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.default = update;
|
|
4
|
+
const tslib_1 = require("tslib");
|
|
5
|
+
const devkit_1 = require("@nx/devkit");
|
|
6
|
+
const internal_1 = require("@nx/devkit/internal");
|
|
7
|
+
const node_path_1 = require("node:path");
|
|
8
|
+
const ts = tslib_1.__importStar(require("typescript"));
|
|
9
|
+
const internal_2 = require("../../../internal");
|
|
10
|
+
const eslint_file_1 = require("../../generators/utils/eslint-file");
|
|
11
|
+
const ast_utils_1 = require("../../generators/utils/flat-config/ast-utils");
|
|
12
|
+
const config_file_1 = require("../../utils/config-file");
|
|
13
|
+
const RULE = '@nx/directive-checks';
|
|
14
|
+
const LINT_CONFIG_FILES = new Set([
|
|
15
|
+
...config_file_1.ESLINT_CONFIG_FILENAMES,
|
|
16
|
+
...config_file_1.BASE_ESLINT_CONFIG_FILENAMES,
|
|
17
|
+
config_file_1.baseEsLintConfigFile,
|
|
18
|
+
]);
|
|
19
|
+
const TRIGGER_DIRECTIVES = ['depends-on', 'ignore-server-inputs'];
|
|
20
|
+
const ROOT_FLAT_CONFIG_FILENAMES = [
|
|
21
|
+
...config_file_1.BASE_ESLINT_CONFIG_FILENAMES,
|
|
22
|
+
...config_file_1.ESLINT_FLAT_CONFIG_FILENAMES,
|
|
23
|
+
];
|
|
24
|
+
async function update(tree) {
|
|
25
|
+
const flatConfig = (0, internal_2.useFlatConfig)(tree) && !hasOnlyEslintrcBaseConfig(tree);
|
|
26
|
+
const sharedConfig = findSharedConfig(tree, flatConfig);
|
|
27
|
+
if (!sharedConfig) {
|
|
28
|
+
return;
|
|
29
|
+
}
|
|
30
|
+
let usesNxEslintPlugin = false;
|
|
31
|
+
let ruleConfigured = false;
|
|
32
|
+
(0, devkit_1.visitNotIgnoredFiles)(tree, '', (path) => {
|
|
33
|
+
if (!LINT_CONFIG_FILES.has((0, node_path_1.basename)(path))) {
|
|
34
|
+
return;
|
|
35
|
+
}
|
|
36
|
+
const content = tree.read(path, 'utf-8');
|
|
37
|
+
usesNxEslintPlugin ||= /@nx[/"']/.test(content);
|
|
38
|
+
ruleConfigured ||= content.includes(RULE);
|
|
39
|
+
});
|
|
40
|
+
if (!usesNxEslintPlugin || ruleConfigured) {
|
|
41
|
+
return;
|
|
42
|
+
}
|
|
43
|
+
if (!(await hasDirectiveFiles(tree))) {
|
|
44
|
+
return;
|
|
45
|
+
}
|
|
46
|
+
// ESLint fails on an `@nx/` rule for a file the plugin isn't registered for,
|
|
47
|
+
// so only the shapes Nx generates count as registering it for every file.
|
|
48
|
+
const registersNxPlugin = (0, eslint_file_1.isEslintConfigFileSupported)(sharedConfig) &&
|
|
49
|
+
(flatConfig
|
|
50
|
+
? flatConfigRegistersNxPlugin(tree, sharedConfig)
|
|
51
|
+
: eslintrcRegistersNxPlugin(tree, sharedConfig));
|
|
52
|
+
if (!registersNxPlugin) {
|
|
53
|
+
devkit_1.logger.warn(`Could not verify that \`${sharedConfig}\` registers the \`@nx\` ESLint plugin for the files \`${RULE}\` checks, so the rule was not added. Your files use \`@nx-depends-on\` or \`@nx-ignore-server-inputs\`, so add the rule to an ESLint config that registers \`@nx\` for those files.`);
|
|
54
|
+
return;
|
|
55
|
+
}
|
|
56
|
+
// Without `files`, the rule covers every file the config already lints, and
|
|
57
|
+
// ESLint selects no new files it may lack a parser for.
|
|
58
|
+
if (flatConfig) {
|
|
59
|
+
const content = tree.read(sharedConfig, 'utf-8');
|
|
60
|
+
tree.write(sharedConfig, (0, ast_utils_1.addBlockToFlatConfigExport)(content, (0, ast_utils_1.generateFlatOverride)({ rules: { [RULE]: 'error' } }, (0, eslint_file_1.determineEslintConfigFormat)(content))));
|
|
61
|
+
}
|
|
62
|
+
else {
|
|
63
|
+
(0, devkit_1.updateJson)(tree, sharedConfig, (json) => {
|
|
64
|
+
json.rules = { ...json.rules, [RULE]: 'error' };
|
|
65
|
+
return json;
|
|
66
|
+
});
|
|
67
|
+
}
|
|
68
|
+
await (0, devkit_1.formatFiles)(tree);
|
|
69
|
+
}
|
|
70
|
+
/**
|
|
71
|
+
* The root config that project configs extend: the root base config when there
|
|
72
|
+
* is one, since the root config then belongs to the root project. Unlike
|
|
73
|
+
* `findEslintFile`, it only looks at files in the format ESLint loads.
|
|
74
|
+
*/
|
|
75
|
+
function findSharedConfig(tree, flatConfig) {
|
|
76
|
+
const candidates = flatConfig
|
|
77
|
+
? ROOT_FLAT_CONFIG_FILENAMES
|
|
78
|
+
: [config_file_1.baseEsLintConfigFile, ...config_file_1.ESLINT_OLD_CONFIG_FILENAMES];
|
|
79
|
+
return candidates.find((file) => tree.exists(file));
|
|
80
|
+
}
|
|
81
|
+
// `useFlatConfig` ignores `.eslintrc.base.json`, so it reads a workspace whose
|
|
82
|
+
// only root config is that file as flat config.
|
|
83
|
+
function hasOnlyEslintrcBaseConfig(tree) {
|
|
84
|
+
return (process.env.ESLINT_USE_FLAT_CONFIG !== 'true' &&
|
|
85
|
+
tree.exists(config_file_1.baseEsLintConfigFile) &&
|
|
86
|
+
!ROOT_FLAT_CONFIG_FILENAMES.some((file) => tree.exists(file)));
|
|
87
|
+
}
|
|
88
|
+
// Top-level `plugins` apply to every file; `overrides` don't.
|
|
89
|
+
function eslintrcRegistersNxPlugin(tree, config) {
|
|
90
|
+
const { plugins } = (0, devkit_1.parseJson)(tree.read(config, 'utf-8'));
|
|
91
|
+
return (Array.isArray(plugins) &&
|
|
92
|
+
plugins.some((plugin) => plugin === '@nx' || plugin === '@nx/eslint-plugin'));
|
|
93
|
+
}
|
|
94
|
+
// Only a `...nx.configs['flat/base']` element directly in the exported array
|
|
95
|
+
// applies to every file.
|
|
96
|
+
function flatConfigRegistersNxPlugin(tree, config) {
|
|
97
|
+
const source = ts.createSourceFile(config, tree.read(config, 'utf-8'), ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
|
|
98
|
+
const elements = (0, ast_utils_1.isEsmExport)(source)
|
|
99
|
+
? (0, ast_utils_1.findExportDefault)(source)
|
|
100
|
+
: (0, ast_utils_1.findModuleExports)(source);
|
|
101
|
+
const modules = defaultImports(source);
|
|
102
|
+
return (elements ?? []).some((element) => {
|
|
103
|
+
if (!ts.isSpreadElement(element)) {
|
|
104
|
+
return false;
|
|
105
|
+
}
|
|
106
|
+
const spread = element.expression;
|
|
107
|
+
return (ts.isElementAccessExpression(spread) &&
|
|
108
|
+
ts.isStringLiteral(spread.argumentExpression) &&
|
|
109
|
+
spread.argumentExpression.text === 'flat/base' &&
|
|
110
|
+
ts.isPropertyAccessExpression(spread.expression) &&
|
|
111
|
+
spread.expression.name.text === 'configs' &&
|
|
112
|
+
ts.isIdentifier(spread.expression.expression) &&
|
|
113
|
+
modules.get(spread.expression.expression.text) === '@nx/eslint-plugin');
|
|
114
|
+
});
|
|
115
|
+
}
|
|
116
|
+
/** Module of each `import x from 'm'` and top-level `const x = require('m')`. */
|
|
117
|
+
function defaultImports(source) {
|
|
118
|
+
const modules = new Map();
|
|
119
|
+
for (const statement of source.statements) {
|
|
120
|
+
if (ts.isImportDeclaration(statement) &&
|
|
121
|
+
statement.importClause?.name &&
|
|
122
|
+
!statement.importClause.isTypeOnly &&
|
|
123
|
+
ts.isStringLiteral(statement.moduleSpecifier)) {
|
|
124
|
+
modules.set(statement.importClause.name.text, statement.moduleSpecifier.text);
|
|
125
|
+
}
|
|
126
|
+
else if (ts.isVariableStatement(statement) &&
|
|
127
|
+
statement.declarationList.flags & ts.NodeFlags.Const) {
|
|
128
|
+
for (const { name, initializer } of statement.declarationList
|
|
129
|
+
.declarations) {
|
|
130
|
+
if (ts.isIdentifier(name) &&
|
|
131
|
+
initializer &&
|
|
132
|
+
ts.isCallExpression(initializer) &&
|
|
133
|
+
ts.isIdentifier(initializer.expression) &&
|
|
134
|
+
initializer.expression.text === 'require' &&
|
|
135
|
+
initializer.arguments.length === 1 &&
|
|
136
|
+
ts.isStringLiteral(initializer.arguments[0])) {
|
|
137
|
+
modules.set(name.text, initializer.arguments[0].text);
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
return modules;
|
|
143
|
+
}
|
|
144
|
+
// Atomized e2e targets are named `<ciTargetName>--<file path in the project>`,
|
|
145
|
+
// so the graph narrows the search to the files that can carry the directives.
|
|
146
|
+
// Both parts can contain `--`, so the `<ciTargetName>` target's `dependsOn`,
|
|
147
|
+
// which lists its atomized targets, marks where the file path starts.
|
|
148
|
+
async function hasDirectiveFiles(tree) {
|
|
149
|
+
let graph;
|
|
150
|
+
try {
|
|
151
|
+
graph = await (0, devkit_1.createProjectGraphAsync)();
|
|
152
|
+
}
|
|
153
|
+
catch (e) {
|
|
154
|
+
devkit_1.logger.warn(`Could not create the project graph to look for Nx directives, so \`${RULE}\` was not added. Add it to your ESLint config if your files use \`@nx-depends-on\` or \`@nx-ignore-server-inputs\`.\n${e.message}`);
|
|
155
|
+
return false;
|
|
156
|
+
}
|
|
157
|
+
for (const node of Object.values(graph.nodes)) {
|
|
158
|
+
const targets = node.data.targets ?? {};
|
|
159
|
+
const targetNames = Object.keys(targets);
|
|
160
|
+
for (const [ciTargetName, ciTarget] of Object.entries(targets)) {
|
|
161
|
+
const atomizedTargetNames = (ciTarget.dependsOn ?? [])
|
|
162
|
+
.flatMap((dependency) => projectTargetNames(dependency, node.name, graph, targetNames))
|
|
163
|
+
.filter((name) => name.startsWith(`${ciTargetName}--`) && Object.hasOwn(targets, name));
|
|
164
|
+
for (const targetName of atomizedTargetNames) {
|
|
165
|
+
const file = (0, devkit_1.joinPathFragments)(node.data.root, targetName.slice(ciTargetName.length + 2));
|
|
166
|
+
if (!tree.isFile(file)) {
|
|
167
|
+
continue;
|
|
168
|
+
}
|
|
169
|
+
const directives = (0, internal_1.parseNxDirectives)(tree.read(file, 'utf-8'));
|
|
170
|
+
if (TRIGGER_DIRECTIVES.some((name) => directives.has(name))) {
|
|
171
|
+
return true;
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
return false;
|
|
177
|
+
}
|
|
178
|
+
// The targets of `project` that a `dependsOn` entry selects, resolved the way
|
|
179
|
+
// the task graph resolves them.
|
|
180
|
+
function projectTargetNames(dependency, project, graph, targetNames) {
|
|
181
|
+
try {
|
|
182
|
+
return ((0, internal_1.normalizeDependencyConfigDefinition)(
|
|
183
|
+
// The normalizer writes `projects` onto the object it gets.
|
|
184
|
+
typeof dependency === 'string' ? dependency : { ...dependency }, project, graph, targetNames)
|
|
185
|
+
// A `^` entry leaves `projects` unset.
|
|
186
|
+
.filter((config) => config.projects?.includes(project))
|
|
187
|
+
.map((config) => config.target));
|
|
188
|
+
}
|
|
189
|
+
catch {
|
|
190
|
+
// The task graph rejects the entry too, e.g. a legacy `projects: 'self'`.
|
|
191
|
+
return [];
|
|
192
|
+
}
|
|
193
|
+
}
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
#### Add the `@nx/directive-checks` lint rule
|
|
2
|
+
|
|
3
|
+
Nx 24.1 adds the `@nx/directive-checks` rule to `@nx/eslint-plugin`. It reports mistakes in the `@nx-` directives at the top of a file that Nx ignores or fails on, such as a misspelled directive name or an `@nx-depends-on` pattern that matches no project.
|
|
4
|
+
|
|
5
|
+
The migration adds the rule as `error` to the root ESLint config that project configs extend. That's the root base config (`eslint.base.config.mjs` or `.eslintrc.base.json`) when the workspace has one, and the root config otherwise. It adds the rule when all of these are true:
|
|
6
|
+
|
|
7
|
+
- The root has a supported ESLint config.
|
|
8
|
+
- That config registers the `@nx` plugin for every file in a shape Nx generates: `...nx.configs['flat/base']` directly in the exported array with `nx` imported from `@nx/eslint-plugin`, or `"plugins": ["@nx"]` at the top level of a `.json` config.
|
|
9
|
+
- No ESLint config mentions `@nx/directive-checks`.
|
|
10
|
+
- A file behind an atomized target (`<target>--<file path>`) has `@nx-depends-on` or `@nx-ignore-server-inputs` in its leading comment block.
|
|
11
|
+
|
|
12
|
+
Lint then fails on every problem the rule reports, such as a misspelled `@nx-` directive in any file that config lints. Fix the reported lines.
|
|
13
|
+
|
|
14
|
+
When an ESLint config uses `@nx/eslint-plugin` but the migration can't verify that the config it would change registers it for every file, it leaves that config unchanged and prints a warning. It does the same for a root config it can't edit, such as `eslint.config.ts`. Add the rule to a config that registers `@nx` for the files it checks.
|
|
15
|
+
|
|
16
|
+
The migration adds the rule without a `files` pattern. In a flat config it adds its own entry, and in `.eslintrc.json` it adds a top-level rule. The rule then runs on every file the config already lints, and ESLint doesn't start linting files that no parser is set up for.
|
|
17
|
+
|
|
18
|
+
#### Sample code changes
|
|
19
|
+
|
|
20
|
+
##### Before
|
|
21
|
+
|
|
22
|
+
```js title="eslint.config.mjs"
|
|
23
|
+
import nx from '@nx/eslint-plugin';
|
|
24
|
+
|
|
25
|
+
export default [
|
|
26
|
+
...nx.configs['flat/base'],
|
|
27
|
+
...nx.configs['flat/typescript'],
|
|
28
|
+
...nx.configs['flat/javascript'],
|
|
29
|
+
// ... other config
|
|
30
|
+
];
|
|
31
|
+
```
|
|
32
|
+
|
|
33
|
+
##### After
|
|
34
|
+
|
|
35
|
+
```js title="eslint.config.mjs"
|
|
36
|
+
import nx from '@nx/eslint-plugin';
|
|
37
|
+
|
|
38
|
+
export default [
|
|
39
|
+
...nx.configs['flat/base'],
|
|
40
|
+
...nx.configs['flat/typescript'],
|
|
41
|
+
...nx.configs['flat/javascript'],
|
|
42
|
+
// ... other config
|
|
43
|
+
{
|
|
44
|
+
rules: {
|
|
45
|
+
'@nx/directive-checks': 'error',
|
|
46
|
+
},
|
|
47
|
+
},
|
|
48
|
+
];
|
|
49
|
+
```
|
package/migrations.json
CHANGED
|
@@ -47,6 +47,12 @@
|
|
|
47
47
|
"description": "Replaces the removed `setParserOptionsProject` generator option with `enableTypedLinting` in the generator defaults of `nx.json` and project configuration, so generators resolve typed linting as before.",
|
|
48
48
|
"implementation": "./dist/src/migrations/update-24-0-0/replace-set-parser-options-project",
|
|
49
49
|
"documentation": "./dist/src/migrations/update-24-0-0/replace-set-parser-options-project.md"
|
|
50
|
+
},
|
|
51
|
+
"update-24-1-0-add-directive-checks-rule": {
|
|
52
|
+
"version": "24.1.0-beta.1",
|
|
53
|
+
"description": "Adds the `@nx/directive-checks` rule to the root ESLint config that project configs extend, in workspaces whose files use the `@nx-depends-on` or `@nx-ignore-server-inputs` directives.",
|
|
54
|
+
"implementation": "./dist/src/migrations/update-24-1-0/add-directive-checks-rule",
|
|
55
|
+
"documentation": "./dist/src/migrations/update-24-1-0/add-directive-checks-rule.md"
|
|
50
56
|
}
|
|
51
57
|
},
|
|
52
58
|
"packageJsonUpdates": {
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@nx/eslint",
|
|
3
|
-
"version": "24.0.
|
|
3
|
+
"version": "24.1.0-beta.1",
|
|
4
4
|
"private": false,
|
|
5
5
|
"type": "commonjs",
|
|
6
6
|
"files": [
|
|
@@ -71,19 +71,19 @@
|
|
|
71
71
|
}
|
|
72
72
|
},
|
|
73
73
|
"peerDependencies": {
|
|
74
|
-
"@nx/jest": "24.0.
|
|
74
|
+
"@nx/jest": "24.1.0-beta.1",
|
|
75
75
|
"@zkochan/js-yaml": "0.0.7",
|
|
76
76
|
"eslint": "^9.0.0 || ^10.0.0"
|
|
77
77
|
},
|
|
78
78
|
"dependencies": {
|
|
79
|
-
"@nx/devkit": "24.0.
|
|
80
|
-
"@nx/js": "24.0.
|
|
79
|
+
"@nx/devkit": "24.1.0-beta.1",
|
|
80
|
+
"@nx/js": "24.1.0-beta.1",
|
|
81
81
|
"semver": "^7.6.3",
|
|
82
82
|
"tslib": "^2.3.0",
|
|
83
83
|
"typescript": "~6.0.3"
|
|
84
84
|
},
|
|
85
85
|
"devDependencies": {
|
|
86
|
-
"nx": "24.0.
|
|
86
|
+
"nx": "24.1.0-beta.1"
|
|
87
87
|
},
|
|
88
88
|
"peerDependenciesMeta": {
|
|
89
89
|
"@nx/jest": {
|