@nx/devkit 0.0.0-pr-22179-271588f

package/src/migrations/update-16-9-0/migrate-mf-util-usage.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const visit_not_ignored_files_1 = require("../../generators/visit-not-ignored-files");
+const format_files_1 = require("../../generators/format-files");
+const nx_1 = require("../../../nx");
+const package_json_1 = require("../../utils/package-json");
+const versions_1 = require("../../utils/versions");
+const { readJson } = (0, nx_1.requireNx)();
+let tsModule;
+const MODULE_FEDERATION_PUBLIC_TOKENS = [
+    'AdditionalSharedConfig',
+    'ModuleFederationConfig',
+    'SharedLibraryConfig',
+    'SharedWorkspaceLibraryConfig',
+    'WorkspaceLibrary',
+    'SharedFunction',
+    'WorkspaceLibrarySecondaryEntryPoint',
+    'Remotes',
+    'ModuleFederationLibrary',
+    'applySharedFunction',
+    'applyAdditionalShared',
+    'getNpmPackageSharedConfig',
+    'shareWorkspaceLibraries',
+    'sharePackages',
+    'mapRemotes',
+    'mapRemotesForSSR',
+    'getDependentPackagesForProject',
+    'readRootPackageJson',
+];
+exports.default = async (tree) => {
+    let hasFileToMigrate = false;
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, '/', (path) => {
+        if (!path.endsWith('.ts') && !path.endsWith('.js')) {
+            return;
+        }
+        let fileContents = tree.read(path, 'utf-8');
+        if (MODULE_FEDERATION_PUBLIC_TOKENS.every((token) => !fileContents.includes(token))) {
+            return;
+        }
+        hasFileToMigrate = true;
+        fileContents = replaceTSImports(tree, path, fileContents);
+        fileContents = replaceRequireCalls(tree, path, fileContents);
+        fileContents = replaceJSDoc(tree, path, fileContents);
+        tree.write(path, fileContents);
+    });
+    if (hasFileToMigrate) {
+        await (0, format_files_1.formatFiles)(tree);
+        const pkgJson = readJson(tree, 'package.json');
+        const nxVersion = pkgJson.devDependencies?.['nx'] ??
+            pkgJson.dependencies?.['nx'] ??
+            '17.0.0';
+        return (0, package_json_1.addDependenciesToPackageJson)(tree, {}, { '@nx/webpack': nxVersion });
+    }
+};
+function replaceJSDoc(tree, path, fileContents) {
+    let newFileContents = fileContents;
+    for (const token of MODULE_FEDERATION_PUBLIC_TOKENS) {
+        newFileContents = newFileContents.replaceAll(new RegExp(`(@type)+\\s({)+(\\s)*(import\\(('|")+@nx\/devkit('|")+\\)\.)+(${token})+\\s*(})+`, 'g'), `@type {import('@nx/webpack').${token}}`);
+    }
+    return newFileContents;
+}
+function replaceRequireCalls(tree, path, fileContents) {
+    if (!tsModule) {
+        tsModule = (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+    }
+    const sourceFile = tsModule.createSourceFile(path, fileContents, tsModule.ScriptTarget.Latest, true);
+    const allDevkitRequires = findNodes(sourceFile, tsModule.SyntaxKind.VariableStatement)
+        .filter((node) => [`require("@nx/devkit")`, `require('@nx/devkit')`].some((r) => node.getText().includes(r)))
+        .filter((node) => findNodes(node, tsModule.SyntaxKind.ObjectBindingPattern).length);
+    const mfUtilRequires = allDevkitRequires.filter((node) => MODULE_FEDERATION_PUBLIC_TOKENS.some((token) => node.getText().includes(token)));
+    if (!mfUtilRequires.length) {
+        return fileContents;
+    }
+    const mfUtilTokens = mfUtilRequires.map((node) => {
+        const allTokens = findNodes(node, tsModule.SyntaxKind.BindingElement);
+        const mfTokens = allTokens.filter((node) => MODULE_FEDERATION_PUBLIC_TOKENS.some((token) => node.getText() === token));
+        return {
+            requireNode: node,
+            onlyMf: allTokens.length === mfTokens.length,
+            mfTokens,
+        };
+    });
+    const changes = [];
+    for (const mfUtilRequireData of mfUtilTokens) {
+        if (mfUtilRequireData.onlyMf) {
+            changes.push({
+                startPosition: mfUtilRequireData.requireNode.getStart(),
+                endPosition: mfUtilRequireData.requireNode.getEnd(),
+                content: '',
+            });
+        }
+        else {
+            for (const mfToken of mfUtilRequireData.mfTokens) {
+                const replaceTrailingComma = mfToken.getText().charAt(mfToken.getEnd() + 1) === ',';
+                changes.push({
+                    startPosition: mfToken.getStart(),
+                    endPosition: replaceTrailingComma
+                        ? mfToken.getEnd() + 1
+                        : mfToken.getEnd(),
+                    content: '',
+                });
+            }
+        }
+    }
+    changes.push({
+        startPosition: mfUtilTokens[mfUtilTokens.length - 1].requireNode.getEnd(),
+        content: `\nconst { ${mfUtilTokens
+            .map((mfUtilToken) => mfUtilToken.mfTokens.map((node) => node.getText()))
+            .join(', ')} } = require('@nx/webpack');`,
+    });
+    let newFileContents = fileContents;
+    while (changes.length) {
+        const change = changes.pop();
+        newFileContents = `${newFileContents.substring(0, change.startPosition)}${change.content}${newFileContents.substring(change.endPosition ? change.endPosition : change.startPosition)}`;
+    }
+    return newFileContents;
+}
+function replaceTSImports(tree, path, fileContents) {
+    if (!tsModule) {
+        tsModule = (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+    }
+    const sourceFile = tsModule.createSourceFile(path, fileContents, tsModule.ScriptTarget.Latest, true);
+    const allImports = findNodes(sourceFile, tsModule.SyntaxKind.ImportDeclaration);
+    const devkitImports = allImports.filter((i) => i.getText().includes(`'@nx/devkit';`));
+    const mfUtilsImports = devkitImports.filter((i) => MODULE_FEDERATION_PUBLIC_TOKENS.some((token) => i.getText().includes(token)));
+    if (!mfUtilsImports.length) {
+        return fileContents;
+    }
+    const mfUtilsWithMultipleImports = mfUtilsImports.map((i) => {
+        const importSpecifierNodes = findNodes(i, tsModule.SyntaxKind.ImportSpecifier);
+        const mfImportSpecifierNodes = importSpecifierNodes.filter((node) => MODULE_FEDERATION_PUBLIC_TOKENS.some((token) => node.getText().includes(token)));
+        return {
+            importDeclarationNode: i,
+            onlyMf: mfImportSpecifierNodes.length === importSpecifierNodes.length,
+            mfImportSpecifierNodes,
+        };
+    });
+    const changes = [];
+    for (const importDeclaration of mfUtilsWithMultipleImports) {
+        if (importDeclaration.onlyMf) {
+            changes.push({
+                startPosition: importDeclaration.importDeclarationNode.getStart(),
+                endPosition: importDeclaration.importDeclarationNode.getEnd(),
+                content: '',
+            });
+        }
+        else {
+            for (const mfImportSpecifierNodes of importDeclaration.mfImportSpecifierNodes) {
+                const replaceTrailingComma = importDeclaration.importDeclarationNode
+                    .getText()
+                    .charAt(mfImportSpecifierNodes.getEnd() + 1) === ',';
+                changes.push({
+                    startPosition: mfImportSpecifierNodes.getStart(),
+                    endPosition: replaceTrailingComma
+                        ? mfImportSpecifierNodes.getEnd() + 1
+                        : mfImportSpecifierNodes.getEnd(),
+                    content: '',
+                });
+            }
+        }
+    }
+    changes.push({
+        startPosition: mfUtilsWithMultipleImports[mfUtilsWithMultipleImports.length - 1].importDeclarationNode.getEnd(),
+        content: `\nimport { ${mfUtilsWithMultipleImports
+            .map((importDeclaration) => importDeclaration.mfImportSpecifierNodes.map((node) => node.getText()))
+            .join(', ')} } from '@nx/webpack';`,
+    });
+    let newFileContents = fileContents;
+    while (changes.length) {
+        const change = changes.pop();
+        newFileContents = `${newFileContents.substring(0, change.startPosition)}${change.content}${newFileContents.substring(change.endPosition ? change.endPosition : change.startPosition)}`;
+    }
+    return newFileContents;
+}
+function findNodes(node, kind, max = Infinity) {
+    if (!node || max == 0) {
+        return [];
+    }
+    const arr = [];
+    const hasMatch = Array.isArray(kind)
+        ? kind.includes(node.kind)
+        : node.kind === kind;
+    if (hasMatch) {
+        arr.push(node);
+        max--;
+    }
+    if (max > 0) {
+        for (const child of node.getChildren()) {
+            findNodes(child, kind, max).forEach((node) => {
+                if (max > 0) {
+                    arr.push(node);
+                }
+                max--;
+            });
+            if (max <= 0) {
+                break;
+            }
+        }
+    }
+    return arr;
+}

package/src/tasks/install-packages-task.d.ts

@@ -0,0 +1,10 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { PackageManager } from 'nx/src/utils/package-manager';
+/**
+ * Runs `npm install` or `yarn install`. It will skip running the install if
+ * `package.json` hasn't changed at all or it hasn't changed since the last invocation.
+ *
+ * @param tree - the file system tree
+ * @param alwaysRun - always run the command even if `package.json` hasn't changed.
+ */
+export declare function installPackagesTask(tree: Tree, alwaysRun?: boolean, cwd?: string, packageManager?: PackageManager): void;

package/src/tasks/install-packages-task.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackagesTask = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const nx_1 = require("../../nx");
+const { detectPackageManager, getPackageManagerCommand, joinPathFragments } = (0, nx_1.requireNx)();
+/**
+ * Runs `npm install` or `yarn install`. It will skip running the install if
+ * `package.json` hasn't changed at all or it hasn't changed since the last invocation.
+ *
+ * @param tree - the file system tree
+ * @param alwaysRun - always run the command even if `package.json` hasn't changed.
+ */
+function installPackagesTask(tree, alwaysRun = false, cwd = '', packageManager = detectPackageManager(cwd)) {
+    if (!tree
+        .listChanges()
+        .find((f) => f.path === joinPathFragments(cwd, 'package.json')) &&
+        !alwaysRun) {
+        return;
+    }
+    const packageJsonValue = tree.read(joinPathFragments(cwd, 'package.json'), 'utf-8');
+    let storedPackageJsonValue = global['__packageJsonInstallCache__'];
+    // Don't install again if install was already executed with package.json
+    if (storedPackageJsonValue != packageJsonValue || alwaysRun) {
+        global['__packageJsonInstallCache__'] = packageJsonValue;
+        const pmc = getPackageManagerCommand(packageManager);
+        const execSyncOptions = {
+            cwd: (0, path_1.join)(tree.root, cwd),
+            stdio: process.env.NX_GENERATE_QUIET === 'true' ? 'ignore' : 'inherit',
+        };
+        // ensure local registry from process is not interfering with the install
+        // when we start the process from temp folder the local registry would override the custom registry
+        if (process.env.npm_config_registry &&
+            process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
+            delete process.env.npm_config_registry;
+        }
+        (0, child_process_1.execSync)(pmc.install, execSyncOptions);
+    }
+}
+exports.installPackagesTask = installPackagesTask;

package/src/utils/async-iterable/combine-async-iterables.d.ts

@@ -0,0 +1,3 @@
+export declare function combineAsyncIterables<T = any>(..._iterators: {
+    0: AsyncIterable<T>;
+} & AsyncIterable<T>[]): AsyncGenerator<T>;

package/src/utils/async-iterable/combine-async-iterables.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineAsyncIterables = void 0;
+async function* combineAsyncIterables(..._iterators) {
+    // Convert iterables into iterators with next, return, throws methods.
+    // If it's already an iterator, keep it.
+    const iterators = _iterators.map((it) => {
+        if (typeof it['next'] === 'function') {
+            return it;
+        }
+        else {
+            return (async function* wrapped() {
+                for await (const val of it) {
+                    yield val;
+                }
+            })();
+        }
+    });
+    let [options] = iterators;
+    if (typeof options.next === 'function') {
+        options = Object.create(null);
+    }
+    else {
+        iterators.shift();
+    }
+    const getNextAsyncIteratorValue = getNextAsyncIteratorFactory(options);
+    try {
+        const asyncIteratorsValues = new Map(iterators.map((it, idx) => [idx, getNextAsyncIteratorValue(it, idx)]));
+        do {
+            const { iterator, index } = await Promise.race(asyncIteratorsValues.values());
+            if (iterator.done) {
+                asyncIteratorsValues.delete(index);
+            }
+            else {
+                yield iterator.value;
+                asyncIteratorsValues.set(index, getNextAsyncIteratorValue(iterators[index], index));
+            }
+        } while (asyncIteratorsValues.size > 0);
+    }
+    finally {
+        await Promise.allSettled(iterators.map((it) => it['return']?.()));
+    }
+}
+exports.combineAsyncIterables = combineAsyncIterables;
+function getNextAsyncIteratorFactory(options) {
+    return async (asyncIterator, index) => {
+        try {
+            const iterator = await asyncIterator.next();
+            return { index, iterator };
+        }
+        catch (err) {
+            if (options.errorCallback) {
+                options.errorCallback(err, index);
+            }
+            return Promise.reject(err);
+        }
+    };
+}

package/src/utils/async-iterable/create-async-iterable.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncPushCallbacks<T> {
+    next: (value: T) => void;
+    done: () => void;
+    error: (err: unknown) => void;
+}
+export declare function createAsyncIterable<T = unknown>(listener: (ls: AsyncPushCallbacks<T>) => void): AsyncIterable<T>;

package/src/utils/async-iterable/create-async-iterable.js

@@ -0,0 +1,58 @@
+"use strict";
+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) => {
+                    if (done || error)
+                        return;
+                    if (pullQueue.length > 0) {
+                        pullQueue.shift()?.[0]({ value, done: false });
+                    }
+                    else {
+                        pushQueue.push(value);
+                    }
+                },
+                error: (err) => {
+                    if (done || error)
+                        return;
+                    if (pullQueue.length > 0) {
+                        pullQueue.shift()?.[1](err);
+                    }
+                    error = err;
+                },
+                done: () => {
+                    if (pullQueue.length > 0) {
+                        pullQueue.shift()?.[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]);
+                        }
+                    });
+                },
+            };
+        },
+    };
+}
+exports.createAsyncIterable = createAsyncIterable;

package/src/utils/async-iterable/index.d.ts

@@ -0,0 +1,4 @@
+export * from './create-async-iterable';
+export * from './combine-async-iterables';
+export * from './map-async-iteratable';
+export * from './tap-async-iteratable';

package/src/utils/async-iterable/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./create-async-iterable"), exports);
+tslib_1.__exportStar(require("./combine-async-iterables"), exports);
+tslib_1.__exportStar(require("./map-async-iteratable"), exports);
+tslib_1.__exportStar(require("./tap-async-iteratable"), exports);

package/src/utils/async-iterable/map-async-iteratable.d.ts

@@ -0,0 +1 @@
+export declare function mapAsyncIterable<T = any, I = any, O = any>(data: AsyncIterable<T> | AsyncIterableIterator<T>, transform: (input: I, index?: number, data?: AsyncIterable<T> | AsyncIterableIterator<T>) => O): AsyncIterable<O> | AsyncIterableIterator<O>;

package/src/utils/async-iterable/map-async-iteratable.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsyncIterable = void 0;
+async function* mapAsyncIterable(data, transform) {
+    async function* f() {
+        const generator = data[Symbol.asyncIterator] || data[Symbol.iterator];
+        const iterator = generator.call(data);
+        let index = 0;
+        let item = await iterator.next();
+        while (!item.done) {
+            yield await transform(await item.value, index, data);
+            index++;
+            item = await iterator.next();
+        }
+    }
+    return yield* f();
+}
+exports.mapAsyncIterable = mapAsyncIterable;

package/src/utils/async-iterable/tap-async-iteratable.d.ts

@@ -0,0 +1 @@
+export declare function tapAsyncIterable<T = any, I = any, O = any>(data: AsyncIterable<T> | AsyncIterableIterator<T>, fn: (input: I) => void): AsyncIterable<T> | AsyncIterableIterator<T>;

package/src/utils/async-iterable/tap-async-iteratable.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapAsyncIterable = void 0;
+const map_async_iteratable_1 = require("./map-async-iteratable");
+async function* tapAsyncIterable(data, fn) {
+    return yield* (0, map_async_iteratable_1.mapAsyncIterable)(data, (x) => {
+        fn(x);
+        return x;
+    });
+}
+exports.tapAsyncIterable = tapAsyncIterable;

package/src/utils/binary-extensions.d.ts

@@ -0,0 +1 @@
+export declare function isBinaryPath(path: string): boolean;