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

package/src/utils/binary-extensions.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBinaryPath = void 0;
+const path_1 = require("path");
+const binaryExtensions = new Set([
+    // types originally from https://github.com/sindresorhus/binary-extensions/blob/40e44b510d87a63dcf42300bc8fbcb105f45a61c/binary-extensions.json
+    '.3dm',
+    '.3ds',
+    '.3g2',
+    '.3gp',
+    '.7z',
+    '.a',
+    '.aac',
+    '.adp',
+    '.ai',
+    '.aif',
+    '.aiff',
+    '.alz',
+    '.ape',
+    '.apk',
+    '.appimage',
+    '.ar',
+    '.arj',
+    '.asf',
+    '.au',
+    '.avi',
+    '.bak',
+    '.baml',
+    '.bh',
+    '.bin',
+    '.bk',
+    '.bmp',
+    '.btif',
+    '.bz2',
+    '.bzip2',
+    '.cab',
+    '.caf',
+    '.cgm',
+    '.class',
+    '.cmx',
+    '.cpio',
+    '.cr2',
+    '.cur',
+    '.dat',
+    '.dcm',
+    '.deb',
+    '.dex',
+    '.djvu',
+    '.dll',
+    '.dmg',
+    '.dng',
+    '.doc',
+    '.docm',
+    '.docx',
+    '.dot',
+    '.dotm',
+    '.dra',
+    '.DS_Store',
+    '.dsk',
+    '.dts',
+    '.dtshd',
+    '.dvb',
+    '.dwg',
+    '.dxf',
+    '.ecelp4800',
+    '.ecelp7470',
+    '.ecelp9600',
+    '.egg',
+    '.eol',
+    '.eot',
+    '.epub',
+    '.exe',
+    '.f4v',
+    '.fbs',
+    '.fh',
+    '.fla',
+    '.flac',
+    '.flatpak',
+    '.fli',
+    '.flv',
+    '.fpx',
+    '.fst',
+    '.fvt',
+    '.g3',
+    '.gh',
+    '.gif',
+    '.glb',
+    '.graffle',
+    '.gz',
+    '.gzip',
+    '.h261',
+    '.h263',
+    '.h264',
+    '.icns',
+    '.ico',
+    '.ief',
+    '.img',
+    '.ipa',
+    '.iso',
+    '.jar',
+    '.jpeg',
+    '.jpg',
+    '.jpgv',
+    '.jpm',
+    '.jxr',
+    '.key',
+    '.keystore',
+    '.ktx',
+    '.lha',
+    '.lib',
+    '.lvp',
+    '.lz',
+    '.lzh',
+    '.lzma',
+    '.lzo',
+    '.m3u',
+    '.m4a',
+    '.m4v',
+    '.mar',
+    '.mdi',
+    '.mht',
+    '.mid',
+    '.midi',
+    '.mj2',
+    '.mka',
+    '.mkv',
+    '.mmr',
+    '.mng',
+    '.mobi',
+    '.mov',
+    '.movie',
+    '.mp3',
+    '.mp4',
+    '.mp4a',
+    '.mpeg',
+    '.mpg',
+    '.mpga',
+    '.msi',
+    '.mxu',
+    '.nef',
+    '.npx',
+    '.numbers',
+    '.nupkg',
+    '.o',
+    '.odp',
+    '.ods',
+    '.odt',
+    '.oga',
+    '.ogg',
+    '.ogv',
+    '.otf',
+    '.ott',
+    '.pages',
+    '.pbm',
+    '.pbf',
+    '.pcx',
+    '.pdb',
+    '.pdf',
+    '.pea',
+    '.pgm',
+    '.pic',
+    '.png',
+    '.pnm',
+    '.pot',
+    '.potm',
+    '.potx',
+    '.ppa',
+    '.ppam',
+    '.ppm',
+    '.pps',
+    '.ppsm',
+    '.ppsx',
+    '.ppt',
+    '.pptm',
+    '.pptx',
+    '.psd',
+    '.pxd',
+    '.pxz',
+    '.pya',
+    '.pyc',
+    '.pyo',
+    '.pyv',
+    '.qt',
+    '.rar',
+    '.ras',
+    '.raw',
+    '.resources',
+    '.rgb',
+    '.rip',
+    '.rlc',
+    '.rmf',
+    '.rmvb',
+    '.rpm',
+    '.rtf',
+    '.rz',
+    '.s3m',
+    '.s7z',
+    '.scpt',
+    '.sgi',
+    '.shar',
+    '.snap',
+    '.sil',
+    '.sketch',
+    '.slk',
+    '.smv',
+    '.snk',
+    '.so',
+    '.stl',
+    '.suo',
+    '.sub',
+    '.swf',
+    '.tar',
+    '.tbz',
+    '.tbz2',
+    '.tga',
+    '.tgz',
+    '.thmx',
+    '.tif',
+    '.tiff',
+    '.tlz',
+    '.ttc',
+    '.ttf',
+    '.txz',
+    '.udf',
+    '.uvh',
+    '.uvi',
+    '.uvm',
+    '.uvp',
+    '.uvs',
+    '.uvu',
+    '.viv',
+    '.vob',
+    '.war',
+    '.wav',
+    '.wax',
+    '.wbmp',
+    '.wdp',
+    '.weba',
+    '.webm',
+    '.webp',
+    '.whl',
+    '.wim',
+    '.wm',
+    '.wma',
+    '.wmv',
+    '.wmx',
+    '.woff',
+    '.woff2',
+    '.wrm',
+    '.wvx',
+    '.xbm',
+    '.xif',
+    '.xla',
+    '.xlam',
+    '.xls',
+    '.xlsb',
+    '.xlsm',
+    '.xlsx',
+    '.xlt',
+    '.xltm',
+    '.xltx',
+    '.xm',
+    '.xmind',
+    '.xpi',
+    '.xpm',
+    '.xwd',
+    '.xz',
+    '.z',
+    '.zip',
+    '.zipx',
+]);
+function isBinaryPath(path) {
+    return binaryExtensions.has((0, path_1.extname)(path).toLowerCase());
+}
+exports.isBinaryPath = isBinaryPath;

package/src/utils/calculate-hash-for-create-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { CreateNodesContext } from 'nx/src/devkit-exports';
+export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): string;

package/src/utils/calculate-hash-for-create-nodes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHashForCreateNodes = void 0;
+const nx_1 = require("../../nx");
+const path_1 = require("path");
+const { hashWithWorkspaceContext, hashArray, hashObject } = (0, nx_1.requireNx)();
+function calculateHashForCreateNodes(projectRoot, options, context, additionalGlobs = []) {
+    return hashArray([
+        hashWithWorkspaceContext(context.workspaceRoot, [
+            (0, path_1.join)(projectRoot, '**/*'),
+            ...additionalGlobs,
+        ]),
+        hashObject(options),
+    ]);
+}
+exports.calculateHashForCreateNodes = calculateHashForCreateNodes;

package/src/utils/config-utils.d.ts

@@ -0,0 +1,4 @@
+export declare let dynamicImport: Function;
+export declare function loadConfigFile<T extends object = any>(configFilePath: string): Promise<T>;
+export declare function getRootTsConfigPath(): string | null;
+export declare function getRootTsConfigFileName(): string | null;

package/src/utils/config-utils.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootTsConfigFileName = exports.getRootTsConfigPath = exports.loadConfigFile = exports.dynamicImport = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const nx_1 = require("../../nx");
+const { workspaceRoot, registerTsProject } = (0, nx_1.requireNx)();
+exports.dynamicImport = new Function('modulePath', 'return import(modulePath);');
+async function loadConfigFile(configFilePath) {
+    {
+        let module;
+        if ((0, path_1.extname)(configFilePath) === '.ts') {
+            const siblingFiles = (0, fs_1.readdirSync)((0, path_1.dirname)(configFilePath));
+            const tsConfigPath = siblingFiles.includes('tsconfig.json')
+                ? (0, path_1.join)((0, path_1.dirname)(configFilePath), 'tsconfig.json')
+                : getRootTsConfigPath();
+            if (tsConfigPath) {
+                const unregisterTsProject = registerTsProject(tsConfigPath);
+                try {
+                    module = await load(configFilePath);
+                }
+                finally {
+                    unregisterTsProject();
+                }
+            }
+            else {
+                module = await load(configFilePath);
+            }
+        }
+        else {
+            module = await load(configFilePath);
+        }
+        return module.default ?? module;
+    }
+}
+exports.loadConfigFile = loadConfigFile;
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(workspaceRoot, tsConfigFileName) : null;
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const pathExists = (0, fs_1.existsSync)((0, path_1.join)(workspaceRoot, tsConfigName));
+        if (pathExists) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+/**
+ * Load the module after ensuring that the require cache is cleared.
+ */
+async function load(path) {
+    // Clear cache if the path is in the cache
+    if (require.cache[path]) {
+        for (const k of Object.keys(require.cache)) {
+            delete require.cache[k];
+        }
+    }
+    try {
+        // Try using `require` first, which works for CJS modules.
+        // Modules are CJS unless it is named `.mjs` or `package.json` sets type to "module".
+        return require(path);
+    }
+    catch (e) {
+        if (e.code === 'ERR_REQUIRE_ESM') {
+            // If `require` fails to load ESM, try dynamic `import()`.
+            return await (0, exports.dynamicImport)(`${path}?t=${Date.now()}`);
+        }
+        // Re-throw all other errors
+        throw e;
+    }
+}

package/src/utils/convert-nx-executor.d.ts

@@ -0,0 +1,7 @@
+import type { Executor } from 'nx/src/config/misc-interfaces';
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+export declare function convertNxExecutor(executor: Executor): any;

package/src/utils/convert-nx-executor.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNxExecutor = void 0;
+const nx_1 = require("../../nx");
+const { Workspaces, readNxJsonFromDisk, retrieveProjectConfigurationsWithAngularProjects, shutdownPluginWorkers, } = (0, nx_1.requireNx)();
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function convertNxExecutor(executor) {
+    const builderFunction = (options, builderContext) => {
+        const workspaces = new Workspaces(builderContext.workspaceRoot);
+        const nxJsonConfiguration = readNxJsonFromDisk
+            ? readNxJsonFromDisk(builderContext.workspaceRoot)
+            : // TODO(v19): remove readNxJson. This is to be backwards compatible with Nx 16.5 and below.
+                workspaces.readNxJson();
+        const promise = async () => {
+            const projectsConfigurations = retrieveProjectConfigurationsWithAngularProjects
+                ? {
+                    version: 2,
+                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => p.projectNodes ?? p.projects),
+                }
+                : // TODO(v19): remove retrieveProjectConfigurations. This is to be backwards compatible with Nx 16.5 and below.
+                    workspaces.readProjectsConfigurations({
+                        _includeProjectsFromAngularJson: true,
+                    });
+            shutdownPluginWorkers?.();
+            const context = {
+                root: builderContext.workspaceRoot,
+                projectName: builderContext.target.project,
+                targetName: builderContext.target.target,
+                target: builderContext.target.target,
+                configurationName: builderContext.target.configuration,
+                projectsConfigurations,
+                nxJsonConfiguration,
+                cwd: process.cwd(),
+                projectGraph: null,
+                taskGraph: null,
+                isVerbose: false,
+            };
+            return executor(options, context);
+        };
+        return toObservable(promise());
+    };
+    return require('@angular-devkit/architect').createBuilder(builderFunction);
+}
+exports.convertNxExecutor = convertNxExecutor;
+function toObservable(promiseOrAsyncIterator) {
+    return new (require('rxjs').Observable)((subscriber) => {
+        promiseOrAsyncIterator
+            .then((value) => {
+            if (!value.next) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+            else {
+                let asyncIterator = value;
+                function recurse(iterator) {
+                    iterator
+                        .next()
+                        .then((result) => {
+                        if (!result.done) {
+                            subscriber.next(result.value);
+                            recurse(iterator);
+                        }
+                        else {
+                            if (result.value) {
+                                subscriber.next(result.value);
+                            }
+                            subscriber.complete();
+                        }
+                    })
+                        .catch((e) => {
+                        subscriber.error(e);
+                    });
+                }
+                recurse(asyncIterator);
+                return () => {
+                    asyncIterator.return();
+                };
+            }
+        })
+            .catch((err) => {
+            subscriber.error(err);
+        });
+    });
+}

package/src/utils/get-named-inputs.d.ts

@@ -0,0 +1,8 @@
+import type { CreateNodesContext } from 'nx/src/devkit-exports';
+import type { InputDefinition } from 'nx/src/config/workspace-json-project-json';
+/**
+ * Get the named inputs available for a directory
+ */
+export declare function getNamedInputs(directory: string, context: CreateNodesContext): {
+    [inputName: string]: (string | InputDefinition)[];
+};

package/src/utils/get-named-inputs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamedInputs = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const nx_1 = require("../../nx");
+const { readJsonFile } = (0, nx_1.requireNx)();
+/**
+ * Get the named inputs available for a directory
+ */
+function getNamedInputs(directory, context) {
+    const projectJsonPath = (0, path_1.join)(directory, 'project.json');
+    const projectJson = (0, fs_1.existsSync)(projectJsonPath)
+        ? readJsonFile(projectJsonPath)
+        : null;
+    const packageJsonPath = (0, path_1.join)(directory, 'package.json');
+    const packageJson = (0, fs_1.existsSync)(packageJsonPath)
+        ? readJsonFile(packageJsonPath)
+        : null;
+    return {
+        ...context.nxJsonConfiguration.namedInputs,
+        ...packageJson?.nx?.namedInputs,
+        ...projectJson?.namedInputs,
+    };
+}
+exports.getNamedInputs = getNamedInputs;

package/src/utils/get-workspace-layout.d.ts

@@ -0,0 +1,24 @@
+import type { Tree } from 'nx/src/generators/tree';
+/**
+ * Returns workspace defaults. It includes defaults folders for apps and libs,
+ * and the default scope.
+ *
+ * Example:
+ *
+ * ```typescript
+ * { appsDir: 'apps', libsDir: 'libs' }
+ * ```
+ * @param tree - file system tree
+ */
+export declare function getWorkspaceLayout(tree: Tree): {
+    appsDir: string;
+    libsDir: string;
+    standaloneAsDefault: boolean;
+};
+/**
+ * Experimental
+ */
+export declare function extractLayoutDirectory(directory?: string): {
+    layoutDirectory: string | null;
+    projectDirectory?: string;
+};

package/src/utils/get-workspace-layout.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLayoutDirectory = exports.getWorkspaceLayout = void 0;
+const nx_1 = require("../../nx");
+const { readNxJson } = (0, nx_1.requireNx)();
+/**
+ * Returns workspace defaults. It includes defaults folders for apps and libs,
+ * and the default scope.
+ *
+ * Example:
+ *
+ * ```typescript
+ * { appsDir: 'apps', libsDir: 'libs' }
+ * ```
+ * @param tree - file system tree
+ */
+function getWorkspaceLayout(tree) {
+    const nxJson = readNxJson(tree);
+    return {
+        appsDir: nxJson?.workspaceLayout?.appsDir ??
+            inOrderOfPreference(tree, ['apps', 'packages'], '.'),
+        libsDir: nxJson?.workspaceLayout?.libsDir ??
+            inOrderOfPreference(tree, ['libs', 'packages'], '.'),
+        standaloneAsDefault: true,
+    };
+}
+exports.getWorkspaceLayout = getWorkspaceLayout;
+/**
+ * Experimental
+ */
+function extractLayoutDirectory(directory) {
+    if (directory) {
+        directory = directory.startsWith('/') ? directory.substring(1) : directory;
+        for (let dir of ['apps', 'libs', 'packages']) {
+            if (directory.startsWith(dir + '/') || directory === dir) {
+                return {
+                    layoutDirectory: dir,
+                    projectDirectory: directory.substring(dir.length + 1),
+                };
+            }
+        }
+    }
+    return { layoutDirectory: null, projectDirectory: directory };
+}
+exports.extractLayoutDirectory = extractLayoutDirectory;
+function inOrderOfPreference(tree, selectedFolders, defaultChoice) {
+    for (let i = 0; i < selectedFolders.length; ++i) {
+        if (tree.exists(selectedFolders[i]))
+            return selectedFolders[i];
+    }
+    return defaultChoice;
+}

package/src/utils/invoke-nx-generator.d.ts

@@ -0,0 +1,6 @@
+import type { Generator } from 'nx/src/config/misc-interfaces';
+/**
+ * Convert an Nx Generator into an Angular Devkit Schematic.
+ * @param generator The Nx generator to convert to an Angular Devkit Schematic.
+ */
+export declare function convertNxGenerator<T = any>(generator: Generator<T>, skipWritingConfigInOldFormat?: boolean): (generatorOptions: T) => (tree: any, context: any) => Promise<any>;