From 7f08f51ca031f31d0f29ee5660fdb94dff6155c8 Mon Sep 17 00:00:00 2001 From: Caleb Ukle Date: Tue, 23 May 2023 08:30:11 -0500 Subject: [PATCH] chore(repo): debugging --- .circleci/config.yml | 4 +- .../packages/jest/executors/jest.json | 2 +- package.json | 6 +- .../src/executors/cypress/cypress.impl.ts | 7 + packages/jest/src/executors/jest/schema.json | 2 +- .../next/src/executors/server/server.impl.ts | 9 + patches/@nx__cypress@16.3.0-beta.4.patch | 672 ++++++++++++++++++ patches/@nx__devkit@16.3.0-beta.4.patch | 130 ++++ patches/@nx__next@16.3.0-beta.4.patch | 172 +++++ pnpm-lock.yaml | 12 +- 10 files changed, 1008 insertions(+), 8 deletions(-) create mode 100644 patches/@nx__cypress@16.3.0-beta.4.patch create mode 100644 patches/@nx__devkit@16.3.0-beta.4.patch create mode 100644 patches/@nx__next@16.3.0-beta.4.patch diff --git a/.circleci/config.yml b/.circleci/config.yml index 6b18bac9840238..f070cf9717b7f0 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -125,7 +125,7 @@ jobs: NX_E2E_CI_CACHE_KEY: e2e-circleci-<< parameters.os >> SELECTED_PM: << parameters.pm >> NX_E2E_RUN_CYPRESS: 'true' - NX_VERBOSE_LOGGING: 'false' + NX_VERBOSE_LOGGING: 'true' NX_PERF_LOGGING: 'false' steps: - run: @@ -151,7 +151,7 @@ jobs: executor: linux environment: NX_E2E_CI_CACHE_KEY: e2e-circleci-linux - NX_VERBOSE_LOGGING: 'false' + NX_VERBOSE_LOGGING: 'true' NX_DAEMON: 'true' NX_PERF_LOGGING: 'false' steps: diff --git a/docs/generated/packages/jest/executors/jest.json b/docs/generated/packages/jest/executors/jest.json index 21f6d2d65ba10b..324a02e14ab016 100644 --- a/docs/generated/packages/jest/executors/jest.json +++ b/docs/generated/packages/jest/executors/jest.json @@ -108,7 +108,7 @@ "type": "boolean" }, "randomize": { - "description": "Shuffle the order of the tests within a file. The shuffling is based on the seed. This option is only supported using the default jest-circus test runner.", + "description": "Shuffle delte methe order of the tests within a file. The shuffling is based on the seed. This option is only supported using the default jest-circus test runner.", "type": "boolean" }, "runInBand": { diff --git a/package.json b/package.json index 506364e76be1f0..9b18145d8d594a 100644 --- a/package.json +++ b/package.json @@ -350,6 +350,10 @@ "depcheck", "documentation" ] + }, + "pnpm": { + "patchedDependencies": { + "@nx/next@16.3.0-beta.4": "patches/@nx__next@16.3.0-beta.4.patch" + } } } - diff --git a/packages/cypress/src/executors/cypress/cypress.impl.ts b/packages/cypress/src/executors/cypress/cypress.impl.ts index b41b68e99fd7b8..9f4ef472c665e4 100644 --- a/packages/cypress/src/executors/cypress/cypress.impl.ts +++ b/packages/cypress/src/executors/cypress/cypress.impl.ts @@ -72,11 +72,14 @@ export default async function cypressExecutor( for await (const devServerValues of devServerIter) { try { + console.log('Running Cypress...'); success = await runCypress(devServerValues.baseUrl, { ...options, portLockFilePath: devServerValues.portLockFilePath, }); + console.log('Cypress finished', { success }); if (!options.watch) { + console.log('Cypress tests finished, trying to exit the dev server'); devServerIter.return(); break; } @@ -84,6 +87,10 @@ export default async function cypressExecutor( logger.error(e.message); success = false; if (!options.watch) { + console.log( + 'Cypress tests finished with error, trying to exit the dev server', + e + ); devServerIter.return(); break; } diff --git a/packages/jest/src/executors/jest/schema.json b/packages/jest/src/executors/jest/schema.json index d9a4b3b09bf60c..73798cd1e069be 100644 --- a/packages/jest/src/executors/jest/schema.json +++ b/packages/jest/src/executors/jest/schema.json @@ -124,7 +124,7 @@ "type": "boolean" }, "randomize": { - "description": "Shuffle the order of the tests within a file. The shuffling is based on the seed. This option is only supported using the default jest-circus test runner.", + "description": "Shuffle delte methe order of the tests within a file. The shuffling is based on the seed. This option is only supported using the default jest-circus test runner.", "type": "boolean" }, "runInBand": { diff --git a/packages/next/src/executors/server/server.impl.ts b/packages/next/src/executors/server/server.impl.ts index b13d5951a00f87..a9f428d1353ed9 100644 --- a/packages/next/src/executors/server/server.impl.ts +++ b/packages/next/src/executors/server/server.impl.ts @@ -54,6 +54,7 @@ export default async function* serveExecutor( // Client to check if server is ready. const client = new net.Socket(); const cleanupClient = () => { + console.log('cleanupClient'); client.removeAllListeners('connect'); client.removeAllListeners('error'); client.end(); @@ -62,9 +63,11 @@ export default async function* serveExecutor( }; const waitForServerReady = (retries = 30) => { + console.log('waitForServerReady', retries); const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET']; client.once('connect', () => { + console.log('connect'); cleanupClient(); next({ success: true, @@ -73,10 +76,13 @@ export default async function* serveExecutor( }); client.on('error', (err) => { + console.log('error', err); if (retries === 0 || !allowedErrorCodes.includes(err['code'])) { + console.log('actual error'); cleanupClient(); error(err); } else { + console.log('retrying', retries); setTimeout(() => waitForServerReady(retries - 1), 1000); } }); @@ -84,6 +90,7 @@ export default async function* serveExecutor( client.connect({ port, host: '127.0.0.1' }); }; + console.log('spawning', command); const server = spawn(command, { cwd: options.dev ? root : nextDir, stdio: 'inherit', @@ -93,6 +100,7 @@ export default async function* serveExecutor( waitForServerReady(); server.once('exit', (code) => { + console.log('server exit', code); cleanupClient(); if (code === 0) { done(); @@ -102,6 +110,7 @@ export default async function* serveExecutor( }); process.on('exit', async (code) => { + console.log('process exit', code); if (code === 128 + 2) { server.kill('SIGINT'); } else if (code === 128 + 1) { diff --git a/patches/@nx__cypress@16.3.0-beta.4.patch b/patches/@nx__cypress@16.3.0-beta.4.patch new file mode 100644 index 00000000000000..a1254109004794 --- /dev/null +++ b/patches/@nx__cypress@16.3.0-beta.4.patch @@ -0,0 +1,672 @@ +diff --git a/src/executors/cypress/cypress.impl.js b/src/executors/cypress/cypress.impl.js +index 40fcc6a6b04f7942b8695c339b93a4b70264012b..b8d869631aa92f07c4e0d13b9df4105056902dba 100644 +--- a/src/executors/cypress/cypress.impl.js ++++ b/src/executors/cypress/cypress.impl.js +@@ -10,169 +10,178 @@ const cypress_version_1 = require("../../utils/cypress-version"); + const detectPort = require("detect-port"); + const Cypress = require('cypress'); // @NOTE: Importing via ES6 messes the whole test dependencies. + function cypressExecutor(options, context) { +- var _a, e_1, _b, _c; +- return tslib_1.__awaiter(this, void 0, void 0, function* () { +- options = normalizeOptions(options, context); +- // this is used by cypress component testing presets to build the executor contexts with the correct configuration options. +- process.env.NX_CYPRESS_TARGET_CONFIGURATION = context.configurationName; +- let success; ++ var _a, e_1, _b, _c; ++ return tslib_1.__awaiter(this, void 0, void 0, function*() { ++ options = normalizeOptions(options, context); ++ // this is used by cypress component testing presets to build the executor contexts with the correct configuration options. ++ process.env.NX_CYPRESS_TARGET_CONFIGURATION = context.configurationName; ++ let success; ++ const devServerIter = startDevServer(options, context); ++ try { ++ for (var _d = true, devServerIter_1 = tslib_1.__asyncValues(devServerIter), devServerIter_1_1; devServerIter_1_1 = yield devServerIter_1.next(), _a = devServerIter_1_1.done, !_a;) { ++ _c = devServerIter_1_1.value; ++ _d = false; + try { +- for (var _d = true, _e = tslib_1.__asyncValues(startDevServer(options, context)), _f; _f = yield _e.next(), _a = _f.done, !_a;) { +- _c = _f.value; +- _d = false; +- try { +- const devServerValues = _c; +- try { +- success = yield runCypress(devServerValues.baseUrl, Object.assign(Object.assign({}, options), { portLockFilePath: devServerValues.portLockFilePath })); +- if (!options.watch) +- break; +- } +- catch (e) { +- devkit_1.logger.error(e.message); +- success = false; +- if (!options.watch) +- break; +- } +- } +- finally { +- _d = true; +- } ++ const devServerValues = _c; ++ try { ++ console.log('Running Cypress...'); ++ success = yield runCypress(devServerValues.baseUrl, Object.assign(Object.assign({}, options), { portLockFilePath: devServerValues.portLockFilePath })); ++ console.log('Cypress finished', { success }); ++ if (!options.watch) { ++ console.log('Cypress tests finished, trying to exit the dev server'); ++ devServerIter.return(); ++ break; ++ } ++ } ++ catch (e) { ++ devkit_1.logger.error(e.message); ++ success = false; ++ if (!options.watch) { ++ console.log('Cypress tests finished with error, trying to exit the dev server', e); ++ devServerIter.return(); ++ break; + } ++ } + } +- catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { +- try { +- if (!_d && !_a && (_b = _e.return)) yield _b.call(_e); +- } +- finally { if (e_1) throw e_1.error; } ++ _d = true; + } +- return { success }; +- }); ++ } ++ } ++ catch (e_1_1) { e_1 = { error: e_1_1 }; } ++ finally { ++ try { ++ if (!_d && !_a && (_b = devServerIter_1.return)) yield _b.call(devServerIter_1); ++ } ++ finally { if (e_1) throw e_1.error; } ++ } ++ return { success }; ++ }); + } + exports.default = cypressExecutor; + function normalizeOptions(options, context) { +- var _a, _b, _c; +- options.env = options.env || {}; +- if (options.tsConfig) { +- const tsConfigPath = (0, path_1.join)(context.root, options.tsConfig); +- options.env.tsConfig = tsConfigPath; +- process.env.TS_NODE_PROJECT = tsConfigPath; +- } +- if (options.testingType === 'component') { +- const project = (_b = (_a = context === null || context === void 0 ? void 0 : context.projectGraph) === null || _a === void 0 ? void 0 : _a.nodes) === null || _b === void 0 ? void 0 : _b[context.projectName]; +- if ((_c = project === null || project === void 0 ? void 0 : project.data) === null || _c === void 0 ? void 0 : _c.root) { +- options.ctTailwindPath = (0, ct_helpers_1.getTempTailwindPath)(context); +- } ++ var _a, _b, _c; ++ options.env = options.env || {}; ++ if (options.tsConfig) { ++ const tsConfigPath = (0, path_1.join)(context.root, options.tsConfig); ++ options.env.tsConfig = tsConfigPath; ++ process.env.TS_NODE_PROJECT = tsConfigPath; ++ } ++ if (options.testingType === 'component') { ++ const project = (_b = (_a = context === null || context === void 0 ? void 0 : context.projectGraph) === null || _a === void 0 ? void 0 : _a.nodes) === null || _b === void 0 ? void 0 : _b[context.projectName]; ++ if ((_c = project === null || project === void 0 ? void 0 : project.data) === null || _c === void 0 ? void 0 : _c.root) { ++ options.ctTailwindPath = (0, ct_helpers_1.getTempTailwindPath)(context); + } +- checkSupportedBrowser(options); +- warnDeprecatedHeadless(options); +- warnDeprecatedCypressVersion(); +- return options; ++ } ++ checkSupportedBrowser(options); ++ warnDeprecatedHeadless(options); ++ warnDeprecatedCypressVersion(); ++ return options; + } + function checkSupportedBrowser({ browser }) { +- // Browser was not passed in as an option, cypress will use whatever default it has set and we dont need to check it +- if (!browser) { +- return; +- } +- if ((0, cypress_version_1.installedCypressVersion)() >= 4 && browser == 'canary') { +- devkit_1.logger.warn((0, devkit_1.stripIndents) ` ++ // Browser was not passed in as an option, cypress will use whatever default it has set and we dont need to check it ++ if (!browser) { ++ return; ++ } ++ if ((0, cypress_version_1.installedCypressVersion)() >= 4 && browser == 'canary') { ++ devkit_1.logger.warn((0, devkit_1.stripIndents)` + Warning: + You are using a browser that is not supported by cypress v4+. + + Read here for more info: + https://docs.cypress.io/guides/references/migration-guide.html#Launching-Chrome-Canary-with-browser + `); +- return; +- } +- const supportedV3Browsers = ['electron', 'chrome', 'canary', 'chromium']; +- if ((0, cypress_version_1.installedCypressVersion)() <= 3 && +- !supportedV3Browsers.includes(browser)) { +- devkit_1.logger.warn((0, devkit_1.stripIndents) ` ++ return; ++ } ++ const supportedV3Browsers = ['electron', 'chrome', 'canary', 'chromium']; ++ if ((0, cypress_version_1.installedCypressVersion)() <= 3 && ++ !supportedV3Browsers.includes(browser)) { ++ devkit_1.logger.warn((0, devkit_1.stripIndents)` + Warning: + You are using a browser that is not supported by cypress v3. + `); +- return; +- } ++ return; ++ } + } + function warnDeprecatedHeadless({ headless }) { +- if ((0, cypress_version_1.installedCypressVersion)() < 8 || headless === undefined) { +- return; +- } +- if (headless) { +- const deprecatedMsg = (0, devkit_1.stripIndents) ` ++ if ((0, cypress_version_1.installedCypressVersion)() < 8 || headless === undefined) { ++ return; ++ } ++ if (headless) { ++ const deprecatedMsg = (0, devkit_1.stripIndents)` + NOTE: + You can now remove the use of the '--headless' flag during 'cypress run' as this is the default for all browsers.`; +- devkit_1.logger.warn(deprecatedMsg); +- } ++ devkit_1.logger.warn(deprecatedMsg); ++ } + } + function warnDeprecatedCypressVersion() { +- if ((0, cypress_version_1.installedCypressVersion)() < 10) { +- devkit_1.logger.warn((0, devkit_1.stripIndents) ` ++ if ((0, cypress_version_1.installedCypressVersion)() < 10) { ++ devkit_1.logger.warn((0, devkit_1.stripIndents)` + NOTE: + Support for Cypress versions < 10 is deprecated. Please upgrade to at least Cypress version 10. + A generator to migrate from v8 to v10 is provided. See https://nx.dev/cypress/v10-migration-guide + `); +- } ++ } + } + function startDevServer(opts, context) { +- var _a, _b, _c; +- return tslib_1.__asyncGenerator(this, arguments, function* startDevServer_1() { +- var _d, e_2, _e, _f; +- // no dev server, return the provisioned base url +- if (!opts.devServerTarget || opts.skipServe) { +- yield yield tslib_1.__await({ baseUrl: opts.baseUrl }); +- return yield tslib_1.__await(void 0); +- } +- const parsedDevServerTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, context.projectGraph); +- const [targetSupportsWatchOpt] = getValueFromSchema(context, parsedDevServerTarget, 'watch'); +- const overrides = Object.assign({}, (targetSupportsWatchOpt ? { watch: opts.watch } : {})); +- if (opts.port === 'cypress-auto') { +- const freePort = yield tslib_1.__await(getPortForProject(context, parsedDevServerTarget)); +- overrides['port'] = freePort; +- } +- else if (opts.port !== undefined) { +- overrides['port'] = opts.port; +- // zero is a special case that means any valid port so there is no reason to try to 'lock it' +- if (opts.port !== 0) { +- const didLock = attemptToLockPort(opts.port); +- if (!didLock) { +- devkit_1.logger.warn((0, devkit_1.stripIndents) `${opts.port} is potentially already in use by another cypress run. ++ var _a, _b, _c; ++ return tslib_1.__asyncGenerator(this, arguments, function* startDevServer_1() { ++ var _d, e_2, _e, _f; ++ // no dev server, return the provisioned base url ++ if (!opts.devServerTarget || opts.skipServe) { ++ yield yield tslib_1.__await({ baseUrl: opts.baseUrl }); ++ return yield tslib_1.__await(void 0); ++ } ++ const parsedDevServerTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, context.projectGraph); ++ const [targetSupportsWatchOpt] = getValueFromSchema(context, parsedDevServerTarget, 'watch'); ++ const overrides = Object.assign({}, (targetSupportsWatchOpt ? { watch: opts.watch } : {})); ++ if (opts.port === 'cypress-auto') { ++ const freePort = yield tslib_1.__await(getPortForProject(context, parsedDevServerTarget)); ++ overrides['port'] = freePort; ++ } ++ else if (opts.port !== undefined) { ++ overrides['port'] = opts.port; ++ // zero is a special case that means any valid port so there is no reason to try to 'lock it' ++ if (opts.port !== 0) { ++ const didLock = attemptToLockPort(opts.port); ++ if (!didLock) { ++ devkit_1.logger.warn((0, devkit_1.stripIndents)`${opts.port} is potentially already in use by another cypress run. + If the port is in use, try using a different port value or passing --port='cypress-auto' to find a free port.`); +- } +- } + } ++ } ++ } ++ try { ++ for (var _g = true, _h = tslib_1.__asyncValues(yield tslib_1.__await((0, devkit_1.runExecutor)(parsedDevServerTarget, overrides, context))), _j; _j = yield tslib_1.__await(_h.next()), _d = _j.done, !_d;) { ++ _f = _j.value; ++ _g = false; + try { +- for (var _g = true, _h = tslib_1.__asyncValues(yield tslib_1.__await((0, devkit_1.runExecutor)(parsedDevServerTarget, overrides, context))), _j; _j = yield tslib_1.__await(_h.next()), _d = _j.done, !_d;) { +- _f = _j.value; +- _g = false; +- try { +- const output = _f; +- if (!output.success && !opts.watch) +- throw new Error('Could not compile application files'); +- if (!opts.baseUrl && +- !output.baseUrl && +- !((_a = output.info) === null || _a === void 0 ? void 0 : _a.baseUrl) && +- ((_b = output.info) === null || _b === void 0 ? void 0 : _b.port)) { +- output.baseUrl = `http://localhost:${output.info.port}`; +- } +- yield yield tslib_1.__await({ +- baseUrl: opts.baseUrl || output.baseUrl || ((_c = output.info) === null || _c === void 0 ? void 0 : _c.baseUrl), +- portLockFilePath: overrides.port && (0, path_1.join)(__dirname, `${overrides.port}.txt`), +- }); +- } +- finally { +- _g = true; +- } +- } ++ const output = _f; ++ if (!output.success && !opts.watch) ++ throw new Error('Could not compile application files'); ++ if (!opts.baseUrl && ++ !output.baseUrl && ++ !((_a = output.info) === null || _a === void 0 ? void 0 : _a.baseUrl) && ++ ((_b = output.info) === null || _b === void 0 ? void 0 : _b.port)) { ++ output.baseUrl = `http://localhost:${output.info.port}`; ++ } ++ yield yield tslib_1.__await({ ++ baseUrl: opts.baseUrl || output.baseUrl || ((_c = output.info) === null || _c === void 0 ? void 0 : _c.baseUrl), ++ portLockFilePath: overrides.port && (0, path_1.join)(__dirname, `${overrides.port}.txt`), ++ }); + } +- catch (e_2_1) { e_2 = { error: e_2_1 }; } + finally { +- try { +- if (!_g && !_d && (_e = _h.return)) yield tslib_1.__await(_e.call(_h)); +- } +- finally { if (e_2) throw e_2.error; } ++ _g = true; + } +- }); ++ } ++ } ++ catch (e_2_1) { e_2 = { error: e_2_1 }; } ++ finally { ++ try { ++ if (!_g && !_d && (_e = _h.return)) yield tslib_1.__await(_e.call(_h)); ++ } ++ finally { if (e_2) throw e_2.error; } ++ } ++ }); + } + /** + * @whatItDoes Initialize the Cypress test runner with the provided project configuration. +@@ -180,141 +189,141 @@ If the port is in use, try using a different port value or passing --port='cypre + * If `watch` is `true`: Open Cypress in the interactive GUI to interact directly with the application. + */ + function runCypress(baseUrl, opts) { +- var _a, _b; +- return tslib_1.__awaiter(this, void 0, void 0, function* () { +- const cypressVersion = (0, cypress_version_1.installedCypressVersion)(); +- // Cypress expects the folder where a cypress config is present +- const projectFolderPath = (0, path_1.dirname)(opts.cypressConfig); +- const options = { +- project: projectFolderPath, +- configFile: (0, path_1.basename)(opts.cypressConfig), +- }; +- // If not, will use the `baseUrl` normally from `cypress.json` +- if (baseUrl) { +- options.config = { baseUrl }; +- } +- if (opts.browser) { +- options.browser = opts.browser; +- } +- if (opts.env) { +- options.env = opts.env; +- } +- if (opts.spec) { +- options.spec = opts.spec; +- } +- options.tag = opts.tag; +- options.exit = opts.exit; +- options.headed = opts.headed; +- if (opts.headless) { +- options.headless = opts.headless; +- } +- options.record = opts.record; +- options.key = opts.key; +- options.parallel = opts.parallel; +- options.ciBuildId = (_a = opts.ciBuildId) === null || _a === void 0 ? void 0 : _a.toString(); +- options.group = opts.group; +- // renamed in cy 10 +- if (cypressVersion >= 10) { +- (_b = options.config) !== null && _b !== void 0 ? _b : (options.config = {}); +- options.config[opts.testingType] = { +- excludeSpecPattern: opts.ignoreTestFiles, +- }; +- } +- else { +- options.ignoreTestFiles = opts.ignoreTestFiles; +- } +- if (opts.reporter) { +- options.reporter = opts.reporter; +- } +- if (opts.reporterOptions) { +- options.reporterOptions = opts.reporterOptions; +- } +- if (opts.quiet) { +- options.quiet = opts.quiet; +- } +- options.testingType = opts.testingType; +- const result = yield (opts.watch +- ? Cypress.open(options) +- : Cypress.run(options)); +- cleanupTmpFile(opts.ctTailwindPath); +- cleanupTmpFile(opts.portLockFilePath); +- if (process.env.NX_VERBOSE_LOGGING === 'true' && opts.portLockFilePath) { +- (0, fs_1.readdirSync)((0, path_1.dirname)(opts.portLockFilePath)).forEach((f) => { +- if (f.endsWith('.txt')) { +- devkit_1.logger.debug(`Lock file ${f} still present`); +- } +- }); ++ var _a, _b; ++ return tslib_1.__awaiter(this, void 0, void 0, function*() { ++ const cypressVersion = (0, cypress_version_1.installedCypressVersion)(); ++ // Cypress expects the folder where a cypress config is present ++ const projectFolderPath = (0, path_1.dirname)(opts.cypressConfig); ++ const options = { ++ project: projectFolderPath, ++ configFile: (0, path_1.basename)(opts.cypressConfig), ++ }; ++ // If not, will use the `baseUrl` normally from `cypress.json` ++ if (baseUrl) { ++ options.config = { baseUrl }; ++ } ++ if (opts.browser) { ++ options.browser = opts.browser; ++ } ++ if (opts.env) { ++ options.env = opts.env; ++ } ++ if (opts.spec) { ++ options.spec = opts.spec; ++ } ++ options.tag = opts.tag; ++ options.exit = opts.exit; ++ options.headed = opts.headed; ++ if (opts.headless) { ++ options.headless = opts.headless; ++ } ++ options.record = opts.record; ++ options.key = opts.key; ++ options.parallel = opts.parallel; ++ options.ciBuildId = (_a = opts.ciBuildId) === null || _a === void 0 ? void 0 : _a.toString(); ++ options.group = opts.group; ++ // renamed in cy 10 ++ if (cypressVersion >= 10) { ++ (_b = options.config) !== null && _b !== void 0 ? _b : (options.config = {}); ++ options.config[opts.testingType] = { ++ excludeSpecPattern: opts.ignoreTestFiles, ++ }; ++ } ++ else { ++ options.ignoreTestFiles = opts.ignoreTestFiles; ++ } ++ if (opts.reporter) { ++ options.reporter = opts.reporter; ++ } ++ if (opts.reporterOptions) { ++ options.reporterOptions = opts.reporterOptions; ++ } ++ if (opts.quiet) { ++ options.quiet = opts.quiet; ++ } ++ options.testingType = opts.testingType; ++ const result = yield (opts.watch ++ ? Cypress.open(options) ++ : Cypress.run(options)); ++ cleanupTmpFile(opts.ctTailwindPath); ++ cleanupTmpFile(opts.portLockFilePath); ++ if (process.env.NX_VERBOSE_LOGGING === 'true' && opts.portLockFilePath) { ++ (0, fs_1.readdirSync)((0, path_1.dirname)(opts.portLockFilePath)).forEach((f) => { ++ if (f.endsWith('.txt')) { ++ devkit_1.logger.debug(`Lock file ${f} still present`); + } +- /** +- * `cypress.open` is returning `0` and is not of the same type as `cypress.run`. +- * `cypress.open` is the graphical UI, so it will be obvious to know what wasn't +- * working. Forcing the build to success when `cypress.open` is used. +- */ +- return !result.totalFailed && !result.failures; +- }); ++ }); ++ } ++ /** ++ * `cypress.open` is returning `0` and is not of the same type as `cypress.run`. ++ * `cypress.open` is the graphical UI, so it will be obvious to know what wasn't ++ * working. Forcing the build to success when `cypress.open` is used. ++ */ ++ return !result.totalFailed && !result.failures; ++ }); + } + /** + * try to find a free port for the project to run on + * will return undefined if no port is found or the project doesn't have a port option + **/ + function getPortForProject(context, target, defaultPort = 4200) { +- return tslib_1.__awaiter(this, void 0, void 0, function* () { +- const fmtTarget = (0, devkit_1.targetToTargetString)(target); +- const [hasPortOpt, schemaPortValue] = getValueFromSchema(context, target, 'port'); +- let freePort; +- if (hasPortOpt) { +- let normalizedPortValue; +- if (!schemaPortValue) { +- devkit_1.logger.info(`NX ${fmtTarget} did not have a defined port value, checking for free port with the default value of ${defaultPort}`); +- normalizedPortValue = defaultPort; +- } +- else { +- normalizedPortValue = Number(schemaPortValue); +- } +- if (isNaN(normalizedPortValue)) { +- devkit_1.output.warn({ +- title: `Port Not a Number`, +- bodyLines: [ +- `The port value found was not a number or can't be parsed to a number`, +- `When reading the devServerTarget (${fmtTarget}) schema, expected ${schemaPortValue} to be a number but got NaN.`, +- `Nx will use the default value of ${defaultPort} instead.`, +- `You can manually specify a port by setting the 'port' option`, +- ], +- }); +- normalizedPortValue = defaultPort; +- } +- try { +- let attempts = 0; +- // make sure when this check happens in parallel, +- // we don't let the same port be used by multiple projects +- do { +- freePort = yield detectPort(freePort || normalizedPortValue); +- if (attemptToLockPort(freePort)) { +- break; +- } +- attempts++; +- // increment port in case the lock file isn't cleaned up +- freePort++; +- } while (attempts < 20); +- devkit_1.logger.info(`NX Using port ${freePort} for ${fmtTarget}`); +- } +- catch (err) { +- throw new Error((0, devkit_1.stripIndents) `Unable to find a free port for the dev server, ${fmtTarget}. ++ return tslib_1.__awaiter(this, void 0, void 0, function*() { ++ const fmtTarget = (0, devkit_1.targetToTargetString)(target); ++ const [hasPortOpt, schemaPortValue] = getValueFromSchema(context, target, 'port'); ++ let freePort; ++ if (hasPortOpt) { ++ let normalizedPortValue; ++ if (!schemaPortValue) { ++ devkit_1.logger.info(`NX ${fmtTarget} did not have a defined port value, checking for free port with the default value of ${defaultPort}`); ++ normalizedPortValue = defaultPort; ++ } ++ else { ++ normalizedPortValue = Number(schemaPortValue); ++ } ++ if (isNaN(normalizedPortValue)) { ++ devkit_1.output.warn({ ++ title: `Port Not a Number`, ++ bodyLines: [ ++ `The port value found was not a number or can't be parsed to a number`, ++ `When reading the devServerTarget (${fmtTarget}) schema, expected ${schemaPortValue} to be a number but got NaN.`, ++ `Nx will use the default value of ${defaultPort} instead.`, ++ `You can manually specify a port by setting the 'port' option`, ++ ], ++ }); ++ normalizedPortValue = defaultPort; ++ } ++ try { ++ let attempts = 0; ++ // make sure when this check happens in parallel, ++ // we don't let the same port be used by multiple projects ++ do { ++ freePort = yield detectPort(freePort || normalizedPortValue); ++ if (attemptToLockPort(freePort)) { ++ break; ++ } ++ attempts++; ++ // increment port in case the lock file isn't cleaned up ++ freePort++; ++ } while (attempts < 20); ++ devkit_1.logger.info(`NX Using port ${freePort} for ${fmtTarget}`); ++ } ++ catch (err) { ++ throw new Error((0, devkit_1.stripIndents)`Unable to find a free port for the dev server, ${fmtTarget}. + You can disable auto port detection by specifing a port or not passing a value to --port`); +- } +- } +- else { +- devkit_1.output.warn({ +- title: `No Port Option Found`, +- bodyLines: [ +- `The 'port' option is set to 'cypress-auto', but the devServerTarget (${fmtTarget}) does not have a port option.`, +- `Because of this, Nx is unable to verify the port is free before starting the dev server.`, +- `This might cause issues if the devServerTarget is trying to use a port that is already in use.`, +- ], +- }); +- } +- return freePort; +- }); ++ } ++ } ++ else { ++ devkit_1.output.warn({ ++ title: `No Port Option Found`, ++ bodyLines: [ ++ `The 'port' option is set to 'cypress-auto', but the devServerTarget (${fmtTarget}) does not have a port option.`, ++ `Because of this, Nx is unable to verify the port is free before starting the dev server.`, ++ `This might cause issues if the devServerTarget is trying to use a port that is already in use.`, ++ ], ++ }); ++ } ++ return freePort; ++ }); + } + /** + * Check if the given target has the given property in it's options. +@@ -322,54 +331,53 @@ You can disable auto port detection by specifing a port or not passing a value t + * the value will be undefined even if it's in the executor schema. + **/ + function getValueFromSchema(context, target, property) { +- var _a, _b; +- let targetOpts; +- try { +- targetOpts = (0, devkit_1.readTargetOptions)(target, context); +- } +- catch (e) { +- throw new Error(`Unable to read the target options for ${(0, devkit_1.targetToTargetString)(target)}. ++ var _a, _b; ++ let targetOpts; ++ try { ++ targetOpts = (0, devkit_1.readTargetOptions)(target, context); ++ } ++ catch (e) { ++ throw new Error(`Unable to read the target options for ${(0, devkit_1.targetToTargetString)(target)}. + Are you sure this is a valid target? + Was trying to read the target for the property: '${property}', but got the following error: + ${e.message || e}`); +- } +- let targetHasOpt = Object.keys(targetOpts).includes(property); +- if (!targetHasOpt) { +- // NOTE: readTargetOptions doesn't apply non defaulted values, i.e. @nx/vite has a port options but is optional +- // so we double check the schema if readTargetOptions didn't return a value for the property +- const projectConfig = (_b = (_a = context.projectsConfigurations) === null || _a === void 0 ? void 0 : _a.projects) === null || _b === void 0 ? void 0 : _b[target.project]; +- const targetConfig = projectConfig.targets[target.target]; +- const workspace = new devkit_1.Workspaces(context.root); +- const [collection, executor] = targetConfig.executor.split(':'); +- const { schema } = workspace.readExecutor(collection, executor); +- // NOTE: schema won't have a default since readTargetOptions would have +- // already set that and this check wouldn't need to be made +- targetHasOpt = Object.keys(schema.properties).includes(property); +- } +- return [targetHasOpt, targetOpts[property]]; ++ } ++ let targetHasOpt = Object.keys(targetOpts).includes(property); ++ if (!targetHasOpt) { ++ // NOTE: readTargetOptions doesn't apply non defaulted values, i.e. @nx/vite has a port options but is optional ++ // so we double check the schema if readTargetOptions didn't return a value for the property ++ const projectConfig = (_b = (_a = context.projectsConfigurations) === null || _a === void 0 ? void 0 : _a.projects) === null || _b === void 0 ? void 0 : _b[target.project]; ++ const targetConfig = projectConfig.targets[target.target]; ++ const workspace = new devkit_1.Workspaces(context.root); ++ const [collection, executor] = targetConfig.executor.split(':'); ++ const { schema } = workspace.readExecutor(collection, executor); ++ // NOTE: schema won't have a default since readTargetOptions would have ++ // already set that and this check wouldn't need to be made ++ targetHasOpt = Object.keys(schema.properties).includes(property); ++ } ++ return [targetHasOpt, targetOpts[property]]; + } + function attemptToLockPort(port) { +- const portLockFilePath = (0, path_1.join)(__dirname, `${port}.txt`); +- try { +- if ((0, fs_1.existsSync)(portLockFilePath)) { +- return false; +- } +- (0, fs_1.writeFileSync)(portLockFilePath, 'locked'); +- return true; +- } +- catch (err) { +- return false; ++ const portLockFilePath = (0, path_1.join)(__dirname, `${port}.txt`); ++ try { ++ if ((0, fs_1.existsSync)(portLockFilePath)) { ++ return false; + } ++ (0, fs_1.writeFileSync)(portLockFilePath, 'locked'); ++ return true; ++ } ++ catch (err) { ++ return false; ++ } + } + function cleanupTmpFile(path) { +- try { +- if (path && (0, fs_1.existsSync)(path)) { +- (0, fs_1.unlinkSync)(path); +- } +- return true; +- } +- catch (err) { +- return false; ++ try { ++ if (path && (0, fs_1.existsSync)(path)) { ++ (0, fs_1.unlinkSync)(path); + } ++ return true; ++ } ++ catch (err) { ++ return false; ++ } + } +-//# sourceMappingURL=cypress.impl.js.map \ No newline at end of file diff --git a/patches/@nx__devkit@16.3.0-beta.4.patch b/patches/@nx__devkit@16.3.0-beta.4.patch new file mode 100644 index 00000000000000..930910e998ecee --- /dev/null +++ b/patches/@nx__devkit@16.3.0-beta.4.patch @@ -0,0 +1,130 @@ +diff --git a/src/utils/async-iterable/create-async-iterable.js b/src/utils/async-iterable/create-async-iterable.js +index fa52c15f2dd6d19178d8df77e26d8703987f29c7..37b90e5fd40bf3d912e1e03ed6c0d59cace825dc 100644 +--- a/src/utils/async-iterable/create-async-iterable.js ++++ b/src/utils/async-iterable/create-async-iterable.js +@@ -2,61 +2,71 @@ + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createAsyncIterable = void 0; + function createAsyncIterable(listener) { +- let done = false; +- let error = null; +- const pushQueue = []; +- const pullQueue = []; +- return { +- [Symbol.asyncIterator]() { +- listener({ +- next: (value) => { +- var _a; +- if (done || error) +- return; +- if (pullQueue.length > 0) { +- (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[0]({ value, done: false }); +- } +- else { +- pushQueue.push(value); +- } +- }, +- error: (err) => { +- var _a; +- if (done || error) +- return; +- if (pullQueue.length > 0) { +- (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[1](err); +- } +- error = err; +- }, +- done: () => { +- var _a; +- if (pullQueue.length > 0) { +- (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[0]({ value: undefined, done: true }); +- } +- done = true; +- }, +- }); +- return { +- next() { +- return new Promise((resolve, reject) => { +- if (pushQueue.length > 0) { +- resolve({ value: pushQueue.shift(), done: false }); +- } +- else if (done) { +- resolve({ value: undefined, done: true }); +- } +- else if (error) { +- reject(error); +- } +- else { +- pullQueue.push([resolve, reject]); +- } +- }); +- }, +- }; ++ let done = false; ++ let error = null; ++ const pushQueue = []; ++ const pullQueue = []; ++ return { ++ [Symbol.asyncIterator]() { ++ listener({ ++ next: (value) => { ++ console.log('createAsyncIterable, next', value) ++ var _a; ++ if (done || error) { ++ console.log('createAsyncIterable, next, done or error', { done, error }) ++ return; ++ } ++ if (pullQueue.length > 0) { ++ (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[0]({ value, done: false }); ++ } ++ else { ++ pushQueue.push(value); ++ } + }, +- }; ++ error: (err) => { ++ console.log('createAsyncIterable, error', err) ++ var _a; ++ if (done || error) { ++ console.log('createAsyncIterable, error, done or error', { done, error }) ++ ++ return; ++ } ++ if (pullQueue.length > 0) { ++ (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[1](err); ++ } ++ error = err; ++ }, ++ done: () => { ++ console.log('createAsyncIterable, done', { done, error, pushQueue, pullQueue }) ++ var _a; ++ if (pullQueue.length > 0) { ++ console.log('createAsyncIterable, done, pullQueue.length > 0', { done, error, pushQueue, pullQueue }) ++ (_a = pullQueue.shift()) === null || _a === void 0 ? void 0 : _a[0]({ value: undefined, done: true }); ++ } ++ done = true; ++ }, ++ }); ++ return { ++ next() { ++ return new Promise((resolve, reject) => { ++ console.log('createAsyncIterable, next, return new Promise', { done, error, pushQueue, pullQueue }) ++ if (pushQueue.length > 0) { ++ resolve({ value: pushQueue.shift(), done: false }); ++ } ++ else if (done) { ++ resolve({ value: undefined, done: true }); ++ } ++ else if (error) { ++ reject(error); ++ } ++ else { ++ pullQueue.push([resolve, reject]); ++ } ++ }); ++ }, ++ }; ++ }, ++ }; + } + exports.createAsyncIterable = createAsyncIterable; + //# sourceMappingURL=create-async-iterable.js.map \ No newline at end of file diff --git a/patches/@nx__next@16.3.0-beta.4.patch b/patches/@nx__next@16.3.0-beta.4.patch new file mode 100644 index 00000000000000..cca429f60d7a77 --- /dev/null +++ b/patches/@nx__next@16.3.0-beta.4.patch @@ -0,0 +1,172 @@ +diff --git a/src/executors/server/server.impl.js b/src/executors/server/server.impl.js +index 9f5b4e742a3f1f0c5a2687187cad8983908cba97..8ab3770060842fa4d251486b7d183a40067f04bc 100644 +--- a/src/executors/server/server.impl.js ++++ b/src/executors/server/server.impl.js +@@ -10,85 +10,89 @@ const custom_server_impl_1 = require("./custom-server.impl"); + const create_cli_options_1 = require("../../utils/create-cli-options"); + const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable"); + function serveExecutor(options, context) { +- return tslib_1.__asyncGenerator(this, arguments, function* serveExecutor_1() { +- if (options.customServerTarget) { +- return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, custom_server_impl_1.default)(options, context))))); ++ return tslib_1.__asyncGenerator(this, arguments, function* serveExecutor_1() { ++ if (options.customServerTarget) { ++ return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, custom_server_impl_1.default)(options, context))))); ++ } ++ // Cast to any to overwrite NODE_ENV ++ process.env.NODE_ENV = process.env.NODE_ENV ++ ? process.env.NODE_ENV ++ : options.dev ++ ? 'development' ++ : 'production'; ++ // Setting port that the custom server should use. ++ process.env.PORT = options.port; ++ const buildOptions = (0, devkit_1.readTargetOptions)((0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph), context); ++ const root = (0, path_1.resolve)(context.root, buildOptions.root); ++ const { port, keepAliveTimeout, hostname } = options; ++ const args = (0, create_cli_options_1.createCliOptions)({ port, keepAliveTimeout, hostname }); ++ const nextDir = (0, path_1.resolve)(context.root, buildOptions.outputPath); ++ const mode = options.dev ? 'dev' : 'start'; ++ const turbo = options.turbo && options.dev ? '--turbo' : ''; ++ const command = `npx next ${mode} ${args} ${turbo}`; ++ yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => { ++ // Client to check if server is ready. ++ const client = new net.Socket(); ++ const cleanupClient = () => { ++ client.removeAllListeners('connect'); ++ client.removeAllListeners('error'); ++ client.end(); ++ client.destroy(); ++ client.unref(); ++ }; ++ const waitForServerReady = (retries = 30) => { ++ const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET']; ++ client.once('connect', () => { ++ var _a; ++ cleanupClient(); ++ next({ ++ success: true, ++ baseUrl: `http://${(_a = options.hostname) !== null && _a !== void 0 ? _a : 'localhost'}:${port}`, ++ }); ++ }); ++ client.on('error', (err) => { ++ if (retries === 0 || !allowedErrorCodes.includes(err['code'])) { ++ cleanupClient(); ++ error(err); ++ } ++ else { ++ setTimeout(() => waitForServerReady(retries - 1), 1000); ++ } ++ }); ++ client.connect({ port, host: '127.0.0.1' }); ++ }; ++ const server = (0, child_process_1.spawn)(command, { ++ cwd: options.dev ? root : nextDir, ++ stdio: 'inherit', ++ shell: true, ++ }); ++ waitForServerReady(); ++ server.once('exit', (code) => { ++ console.log('calling done in server exit') ++ cleanupClient(); ++ if (code === 0) { ++ done(); + } +- // Cast to any to overwrite NODE_ENV +- process.env.NODE_ENV = process.env.NODE_ENV +- ? process.env.NODE_ENV +- : options.dev +- ? 'development' +- : 'production'; +- // Setting port that the custom server should use. +- process.env.PORT = options.port; +- const buildOptions = (0, devkit_1.readTargetOptions)((0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph), context); +- const root = (0, path_1.resolve)(context.root, buildOptions.root); +- const { port, keepAliveTimeout, hostname } = options; +- const args = (0, create_cli_options_1.createCliOptions)({ port, keepAliveTimeout, hostname }); +- const nextDir = (0, path_1.resolve)(context.root, buildOptions.outputPath); +- const mode = options.dev ? 'dev' : 'start'; +- const turbo = options.turbo && options.dev ? '--turbo' : ''; +- const command = `npx next ${mode} ${args} ${turbo}`; +- yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => { +- // Client to check if server is ready. +- const client = new net.Socket(); +- const cleanupClient = () => { +- client.removeAllListeners('connect'); +- client.removeAllListeners('error'); +- client.end(); +- client.destroy(); +- client.unref(); +- }; +- const waitForServerReady = (retries = 30) => { +- const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET']; +- client.once('connect', () => { +- var _a; +- cleanupClient(); +- next({ +- success: true, +- baseUrl: `http://${(_a = options.hostname) !== null && _a !== void 0 ? _a : 'localhost'}:${port}`, +- }); +- }); +- client.on('error', (err) => { +- if (retries === 0 || !allowedErrorCodes.includes(err['code'])) { +- cleanupClient(); +- error(err); +- } +- else { +- setTimeout(() => waitForServerReady(retries - 1), 1000); +- } +- }); +- client.connect({ port, host: '127.0.0.1' }); +- }; +- const server = (0, child_process_1.spawn)(command, { +- cwd: options.dev ? root : nextDir, +- stdio: 'inherit', +- shell: true, +- }); +- waitForServerReady(); +- server.once('exit', (code) => { +- cleanupClient(); +- if (code === 0) { +- done(); +- } +- else { +- error(new Error(`Next.js app exited with code ${code}`)); +- } +- }); +- process.on('exit', (code) => tslib_1.__awaiter(this, void 0, void 0, function* () { +- if (code === 128 + 2) { +- server.kill('SIGINT'); +- } +- else if (code === 128 + 1) { +- server.kill('SIGHUP'); +- } +- else { +- server.kill('SIGTERM'); +- } +- })); +- })))); +- }); ++ else { ++ error(new Error(`Next.js app exited with code ${code}`)); ++ } ++ }); ++ process.on('exit', (code) => { ++ if (code === 128 + 2) { ++ server.kill('SIGINT'); ++ } ++ else if (code === 128 + 1) { ++ server.kill('SIGHUP'); ++ } ++ else { ++ server.kill('SIGTERM'); ++ } ++ console.log('calling done in process exit') ++ cleanupClient(); ++ done(); ++ }); ++ })))); ++ }); + } + exports.default = serveExecutor; + //# sourceMappingURL=server.impl.js.map \ No newline at end of file diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 7d3e83b4a88fda..ea6544dd4992ce 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -5,6 +5,11 @@ overrides: underscore: ^1.12.1 nx: 16.3.0-beta.4 +patchedDependencies: + '@nx/next@16.3.0-beta.4': + hash: hxm3jjjzdnacv7u32j6zyhz65a + path: patches/@nx__next@16.3.0-beta.4.patch + dependencies: '@docsearch/react': specifier: ^3.3.0 @@ -274,7 +279,7 @@ devDependencies: version: 16.3.0-beta.4(@swc-node/register@1.5.4)(@swc/core@1.3.51)(eslint@8.15.0)(nx@16.3.0-beta.4)(typescript@5.0.2) '@nx/next': specifier: 16.3.0-beta.4 - version: 16.3.0-beta.4(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0) + version: 16.3.0-beta.4(patch_hash=hxm3jjjzdnacv7u32j6zyhz65a)(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0) '@nx/react': specifier: 16.3.0-beta.4 version: 16.3.0-beta.4(@swc-node/register@1.5.4)(@swc/core@1.3.51)(eslint@8.15.0)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0) @@ -5368,7 +5373,7 @@ packages: /@nrwl/next@16.3.0-beta.4(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0): resolution: {integrity: sha512-ESWZBHskpT509oauuDqG4uz6gTnlR2M5F12miwQOHC5z4YhWU9asmlD8CftcjMjXW/i1KVr77vag0c2Nq7cRqg==} dependencies: - '@nx/next': 16.3.0-beta.4(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0) + '@nx/next': 16.3.0-beta.4(patch_hash=hxm3jjjzdnacv7u32j6zyhz65a)(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0) transitivePeerDependencies: - '@babel/core' - '@babel/traverse' @@ -5706,7 +5711,7 @@ packages: - typescript dev: true - /@nx/next@16.3.0-beta.4(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0): + /@nx/next@16.3.0-beta.4(patch_hash=hxm3jjjzdnacv7u32j6zyhz65a)(@babel/core@7.19.0)(@swc-node/register@1.5.4)(@swc/core@1.3.51)(@types/express@4.17.14)(@types/node@18.16.9)(eslint@8.15.0)(file-loader@6.2.0)(next@13.3.4)(nx@16.3.0-beta.4)(typescript@5.0.2)(webpack@5.80.0): resolution: {integrity: sha512-UnqAybORMC/QIediCWL4E5+6DaENPDkfu++dHP2lSXjYPzTYovJx0EhCoF1oE6Nm5FG/vXOLaNePChkdCTDQew==} peerDependencies: next: '>=13.0.0' @@ -5749,6 +5754,7 @@ packages: - typescript - webpack dev: true + patched: true /@nx/nx-darwin-arm64@16.3.0-beta.4: resolution: {integrity: sha512-MWribxEJe7Ccnb3yW1GZyijpDDpzKEigYHcd3q9C/wVAItRD8YGFZZwAKhEwpFt9T239deY6nftHDgfep215Jg==}