yeoman-environment 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/module-lookup.js

@@ -0,0 +1,227 @@
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { delimiter, dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import process from 'node:process';
+import arrify from 'arrify';
+import { uniq, compact } from 'lodash-es';
+import { globbySync } from 'globby';
+import slash from 'slash';
+import createdLogger from 'debug';
+import { execaOutput } from './util/util.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const PROJECT_ROOT = join(__dirname, '..');
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const PACKAGE_NAME_PATTERN = [JSON.parse(readFileSync(join(PROJECT_ROOT, 'package.json')).toString()).name];
+const win32 = process.platform === 'win32';
+const nvm = process.env.NVM_HOME;
+const debug = createdLogger('yeoman:environment');
+/**
+ * Search for npm packages.
+ */
+export function moduleLookupSync(options, find) {
+    debug('Running lookup with options: %o', options);
+    options = { ...options };
+    options.filePatterns = arrify(options.filePatterns ?? 'package.json').map(filePattern => slash(filePattern));
+    if (options.packagePaths) {
+        options.packagePaths = arrify(options.packagePaths);
+        if (options.reverse) {
+            options.packagePaths = options.packagePaths.reverse();
+        }
+    }
+    else {
+        options.npmPaths = options.npmPaths ?? getNpmPaths(options);
+        if (options.reverse && Array.isArray(options.npmPaths)) {
+            options.npmPaths = options.npmPaths.reverse();
+        }
+        options.packagePatterns = arrify(options.packagePatterns ?? PACKAGE_NAME_PATTERN).map(packagePattern => slash(packagePattern));
+        options.packagePaths = findPackagesIn(options.npmPaths, options.packagePatterns);
+    }
+    debug('Lookup calculated options: %o', options);
+    const modules = [];
+    for (const packagePath of options.packagePaths) {
+        if (!existsSync(packagePath) || (!lstatSync(packagePath).isDirectory() && !lstatSync(packagePath).isSymbolicLink())) {
+            continue;
+        }
+        const files = globbySync(options.filePatterns, {
+            cwd: packagePath,
+            absolute: true,
+            ...options.globbyOptions,
+        });
+        const filePath = find({ files, packagePath });
+        if (filePath) {
+            return [{ filePath, packagePath }];
+        }
+        for (const filePath of files) {
+            modules.push({ filePath, packagePath });
+        }
+    }
+    return modules;
+}
+/**
+ * Search npm for every available generators.
+ * Generators are npm packages who's name start with `generator-` and who're placed in the
+ * top level `node_module` path. They can be installed globally or locally.
+ *
+ * @method
+ *
+ * @param searchPaths List of search paths
+ * @param packagePatterns Pattern of the packages
+ * @param globbyOptions
+ * @return List of the generator modules path
+ */
+export function findPackagesIn(searchPaths, packagePatterns, globbyOptions) {
+    searchPaths = arrify(searchPaths)
+        .filter(Boolean)
+        .map(npmPath => resolve(npmPath));
+    let modules = [];
+    for (const root of searchPaths) {
+        if (!existsSync(root) || (!lstatSync(root).isDirectory() && !lstatSync(root).isSymbolicLink())) {
+            continue;
+        }
+        // Some folders might not be readable to the current user. For those, we add a try
+        // catch to handle the error gracefully as globby doesn't have an option to skip
+        // restricted folders.
+        try {
+            modules = modules.concat(globbySync(packagePatterns, {
+                cwd: root,
+                onlyDirectories: true,
+                expandDirectories: false,
+                absolute: true,
+                deep: 0,
+                ...globbyOptions,
+            }));
+            // To limit recursive lookups into non-namespace folders within globby,
+            // fetch all namespaces in root, then search each namespace separately
+            // for generator modules
+            const scopes = globbySync(['@*'], {
+                cwd: root,
+                onlyDirectories: true,
+                expandDirectories: false,
+                absolute: true,
+                deep: 0,
+                ...globbyOptions,
+            });
+            for (const scope of scopes) {
+                modules = modules.concat(globbySync(packagePatterns, {
+                    cwd: scope,
+                    onlyDirectories: true,
+                    expandDirectories: false,
+                    absolute: true,
+                    deep: 0,
+                    ...globbyOptions,
+                }));
+            }
+        }
+        catch (error) {
+            debug('Could not access %s (%s)', root, error);
+        }
+    }
+    return modules;
+}
+/**
+ * Get the npm lookup directories (`node_modules/`)
+ *
+ * @method
+ *
+ * @param {boolean|Object} [options]
+ * @param {boolean} [options.localOnly = false] - Set true to skip lookups of
+ *                                               globally-installed generators.
+ * @param {boolean} [options.filterPaths = false] - Remove paths that don't ends
+ *                       with a supported path (don't touch at NODE_PATH paths).
+ * @return {Array} lookup paths
+ */
+export function getNpmPaths(options = {}) {
+    // Resolve signature where options is boolean (localOnly).
+    if (typeof options === 'boolean') {
+        options = { localOnly: options };
+    }
+    // Start with the local paths.
+    let paths = getLocalNpmPaths();
+    // Append global paths, unless they should be excluded.
+    if (!options.localOnly) {
+        paths = paths.concat(getGlobalNpmPaths(options.filterPaths));
+    }
+    return uniq(paths);
+}
+/**
+ * Get the local npm lookup directories
+ * @private
+ * @return {Array} lookup paths
+ */
+function getLocalNpmPaths() {
+    const paths = [];
+    // Walk up the CWD and add `node_modules/` folder lookup on each level
+    process
+        .cwd()
+        .split(sep)
+        .forEach((part, i, parts) => {
+        let lookup = join(...parts.slice(0, i + 1), 'node_modules');
+        if (!win32) {
+            lookup = `/${lookup}`;
+        }
+        paths.push(lookup);
+    });
+    return uniq(paths.reverse());
+}
+/**
+ * Get the global npm lookup directories
+ * Reference: https://nodejs.org/api/modules.html
+ * @private
+ * @return {Array} lookup paths
+ */
+function getGlobalNpmPaths(filterPaths = true) {
+    let paths = [];
+    // Node.js will search in the following list of GLOBAL_FOLDERS:
+    // 1: $HOME/.node_modules
+    // 2: $HOME/.node_libraries
+    // 3: $PREFIX/lib/node
+    const filterValidNpmPath = function (path, ignore = false) {
+        return ignore ? [path] : ['/node_modules', '/.node_modules', '/.node_libraries', '/node'].some(dir => path.endsWith(dir)) ? [path] : [];
+    };
+    // Default paths for each system
+    if (nvm && process.env.NVM_HOME) {
+        paths.push(join(process.env.NVM_HOME, process.version, 'node_modules'));
+    }
+    else if (win32 && process.env.APPDATA) {
+        paths.push(join(process.env.APPDATA, 'npm/node_modules'));
+    }
+    else {
+        paths.push('/usr/lib/node_modules', '/usr/local/lib/node_modules');
+    }
+    // Add NVM prefix directory
+    if (process.env.NVM_PATH) {
+        paths.push(join(dirname(process.env.NVM_PATH), 'node_modules'));
+    }
+    // Adding global npm directories
+    // We tried using npm to get the global modules path, but it haven't work out
+    // because of bugs in the parseable implementation of `ls` command and mostly
+    // performance issues. So, we go with our best bet for now.
+    if (process.env.NODE_PATH) {
+        paths = compact(process.env.NODE_PATH.split(delimiter)).concat(paths);
+    }
+    // Global node_modules should be 4 or 2 directory up this one (most of the time)
+    // Ex: /usr/another_global/node_modules/yeoman-denerator/node_modules/yeoman-environment/lib (1 level dependency)
+    paths.push(...filterValidNpmPath(join(PROJECT_ROOT, '../../..'), !filterPaths));
+    // Ex: /usr/another_global/node_modules/yeoman-environment/lib (installed directly)
+    paths.push(join(PROJECT_ROOT, '..'));
+    // Get yarn global directory and infer the module paths from there
+    const yarnBase = execaOutput('yarn', ['global', 'dir'], { encoding: 'utf8' });
+    if (yarnBase) {
+        paths.push(resolve(yarnBase, 'node_modules'));
+        paths.push(resolve(yarnBase, '../link/'));
+    }
+    // Get npm global prefix and infer the module paths from there
+    const globalInstall = execaOutput('npm', ['root', '-g'], {
+        encoding: 'utf8',
+    });
+    if (globalInstall) {
+        paths.push(resolve(globalInstall));
+    }
+    // Adds support for generator resolving when yeoman-generator has been linked
+    if (process.argv[1]) {
+        paths.push(...filterValidNpmPath(join(dirname(process.argv[1]), '../..'), !filterPaths));
+    }
+    return uniq(paths.filter(Boolean).reverse());
+}

package/dist/package-manager.d.ts

@@ -0,0 +1,18 @@
+import type { MemFsEditorFile } from 'mem-fs-editor';
+import { type InputOutputAdapter } from '@yeoman/types';
+import { type Store } from 'mem-fs';
+export type PackageManagerInstallTaskOptions = {
+    memFs: Store<MemFsEditorFile>;
+    packageJsonLocation: string;
+    adapter: InputOutputAdapter;
+    nodePackageManager?: string;
+    customInstallTask?: boolean | ((nodePackageManager: string | undefined, defaultTask: () => Promise<boolean>) => void | Promise<void>);
+    skipInstall?: boolean;
+};
+/**
+ * Executes package manager install.
+ * - checks if package.json was committed.
+ * - uses a preferred package manager or try to detect.
+ * @return {Promise<boolean>} Promise true if the install execution suceeded.
+ */
+export declare function packageManagerInstallTask({ memFs, packageJsonLocation, customInstallTask, adapter, nodePackageManager, skipInstall, }: PackageManagerInstallTaskOptions): Promise<boolean | void>;

package/dist/package-manager.js

@@ -1,92 +1,75 @@
-import path from 'node:path';
+import { join, resolve } from 'node:path';
 import createdLogger from 'debug';
 import preferredPm from 'preferred-pm';
+import { execa } from 'execa';
 const debug = createdLogger('yeoman:environment:package-manager');
-const packageManagerMixin = cls => class extends cls {
+/**
+ * Executes package manager install.
+ * - checks if package.json was committed.
+ * - uses a preferred package manager or try to detect.
+ * @return {Promise<boolean>} Promise true if the install execution suceeded.
+ */
+/*
+  const { customInstallTask } = this.composedStore;
+  packageJsonFile: join(this.cwd, 'package.json');
+
+*/
+export async function packageManagerInstallTask({ memFs, packageJsonLocation, customInstallTask, adapter, nodePackageManager, skipInstall, }) {
+    packageJsonLocation = resolve(packageJsonLocation);
     /**
      * @private
      * Get the destination package.json file.
      * @return {Vinyl | undefined} a Vinyl file.
      */
-    getDestinationPackageJson() {
-        return this.sharedFs.get(path.resolve(this.cwd, 'package.json'));
+    function getDestinationPackageJson() {
+        return memFs.get(join(packageJsonLocation, 'package.json'));
     }
     /**
      * @private
      * Get the destination package.json commit status.
      * @return {boolean} package.json commit status.
      */
-    isDestinationPackageJsonCommitted() {
-        const file = this.getDestinationPackageJson();
-        return file && file.committed;
+    function isDestinationPackageJsonCommitted() {
+        const file = getDestinationPackageJson();
+        return file.committed;
     }
-    /**
-     * @private
-     * Detect the package manager based on files or use the passed one.
-     * @return {string} package manager.
-     */
-    async detectPackageManager() {
-        if (this.options.nodePackageManager) {
-            return this.options.nodePackageManager;
-        }
-        const pm = await preferredPm(this.cwd);
-        return pm && pm.name;
+    if (!getDestinationPackageJson()) {
+        return false;
     }
-    /**
-     * Executes package manager install.
-     * - checks if package.json was committed.
-     * - uses a preferred package manager or try to detect.
-     * @return {Promise<boolean>} Promise true if the install execution suceeded.
-     */
-    async packageManagerInstallTask() {
-        if (!this.getDestinationPackageJson()) {
-            return false;
-        }
-        if (this.compatibilityMode === 'v4') {
-            debug('Running in generator < 5 compatibility. Package manager install is done by the generator.');
-            return false;
-        }
-        const customInstallTask = this.findGeneratorCustomInstallTask();
-        if (customInstallTask && typeof customInstallTask !== 'function') {
-            debug('Install disabled by customInstallTask');
-            return false;
-        }
-        if (!this.isDestinationPackageJsonCommitted()) {
-            this.adapter.log(`
+    if (customInstallTask && typeof customInstallTask !== 'function') {
+        debug('Install disabled by customInstallTask');
+        return false;
+    }
+    if (!isDestinationPackageJsonCommitted()) {
+        adapter.log(`
 No change to package.json was detected. No package manager install will be executed.`);
-            return false;
-        }
-        this.adapter.log(`
+        return false;
+    }
+    adapter.log(`
 Changes to package.json were detected.`);
-        if (this.options.skipInstall) {
-            this.adapter.log(`Skipping package manager install.
+    if (skipInstall) {
+        adapter.log(`Skipping package manager install.
 `);
+        return false;
+    }
+    // eslint-disable-next-line unicorn/no-await-expression-member
+    let packageManagerName = nodePackageManager ?? (await preferredPm(packageJsonLocation))?.name;
+    const execPackageManager = async () => {
+        if (!packageManagerName) {
+            packageManagerName = 'npm';
+            adapter.log('Error detecting the package manager. Falling back to npm.');
+        }
+        if (!['npm', 'yarn', 'pnpm'].includes(packageManagerName)) {
+            adapter.log(`${packageManagerName} is not a supported package manager. Run it by yourself.`);
             return false;
         }
-        let packageManagerName = await this.detectPackageManager();
-        const execPackageManager = async () => {
-            if (!packageManagerName) {
-                packageManagerName = 'npm';
-                this.adapter.log('Error detecting the package manager. Falling back to npm.');
-            }
-            if (!['npm', 'yarn', 'pnpm'].includes(packageManagerName)) {
-                this.adapter.log(`${packageManagerName} is not a supported package manager. Run it by yourself.`);
-                return false;
-            }
-            this.adapter.log(`
+        adapter.log(`
 Running ${packageManagerName} install for you to install the required dependencies.`);
-            await this.spawnCommand(packageManagerName, ['install']);
-            return true;
-        };
-        if (customInstallTask) {
-            const result = customInstallTask(packageManagerName, execPackageManager);
-            if (!result || !result.then) {
-                return true;
-            }
-            return result;
-        }
-        return execPackageManager();
+        await execa(packageManagerName, ['install'], { stdio: 'inherit', cwd: packageJsonLocation });
+        return true;
+    };
+    if (customInstallTask) {
+        return customInstallTask(packageManagerName, execPackageManager);
     }
-};
-export default packageManagerMixin;
-//# sourceMappingURL=package-manager.js.map
+    return execPackageManager();
+}

package/dist/store.d.ts

@@ -0,0 +1,66 @@
+import type { BaseEnvironment, GetGeneratorConstructor, GeneratorMeta, BaseGeneratorMeta } from '@yeoman/types';
+/**
+ * The Generator store
+ * This is used to store generator (npm packages) reference and instantiate them when
+ * requested.
+ * @constructor
+ * @private
+ */
+export default class Store {
+    private readonly env;
+    private readonly _meta;
+    private readonly _packagesPaths;
+    private readonly _packagesNS;
+    constructor(env: BaseEnvironment);
+    /**
+     * Store a module under the namespace key
+     * @param meta
+     * @param generator - A generator module or a module path
+     */
+    add(meta: BaseGeneratorMeta, Generator?: unknown): GeneratorMeta;
+    /**
+     * Get the module registered under the given namespace
+     * @param  {String} namespace
+     * @return {Module}
+     */
+    get(namespace: string): Promise<GetGeneratorConstructor>;
+    /**
+     * Get the module registered under the given namespace
+     * @param  {String} namespace
+     * @return {Module}
+     */
+    getMeta(namespace: string): GeneratorMeta;
+    /**
+     * Returns the list of registered namespace.
+     * @return {Array} Namespaces array
+     */
+    namespaces(): string[];
+    /**
+     * Get the stored generators meta data
+     * @return {Object} Generators metadata
+     */
+    getGeneratorsMeta(): Record<string, GeneratorMeta>;
+    /**
+     * Store a package under the namespace key
+     * @param {String}     packageNS - The key under which the generator can be retrieved
+     * @param {String}   packagePath - The package path
+     */
+    addPackage(packageNS: string, packagePath: string): void;
+    /**
+     * Get the stored packages namespaces with paths.
+     * @return {Object} Stored packages namespaces with paths.
+     */
+    getPackagesPaths(): Record<string, string[]>;
+    /**
+     * Store a package ns
+     * @param {String} packageNS - The key under which the generator can be retrieved
+     */
+    addPackageNamespace(packageNS: string): void;
+    /**
+     * Get the stored packages namespaces.
+     * @return {Array} Stored packages namespaces.
+     */
+    getPackagesNS(): string[];
+    private getFactory;
+    private _getGenerator;
+}

package/dist/store.js

@@ -1,5 +1,7 @@
+import { pathToFileURL } from 'node:url';
+import { extname, join } from 'node:path';
+import { toNamespace } from '@yeoman/namespace';
 import createDebug from 'debug';
-import { requireOrImport } from './util/esm.js';
 const debug = createDebug('yeoman:environment:store');
 /**
  * The Generator store
@@ -8,45 +10,71 @@ const debug = createDebug('yeoman:environment:store');
  * @constructor
  * @private
  */
-class Store {
-    constructor() {
-        this._meta = {};
-        // Store packages paths by ns
-        this._packagesPaths = {};
-        // Store packages ns
-        this._packagesNS = [];
+export default class Store {
+    env;
+    _meta = {};
+    // Store packages paths by ns
+    _packagesPaths = {};
+    // Store packages ns
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    _packagesNS = [];
+    constructor(env) {
+        this.env = env;
     }
     /**
      * Store a module under the namespace key
-     * @param {String}          namespace  - The key under which the generator can be retrieved
-     * @param {String|Function} generator  - A generator module or a module path
-     * @param {String}         packagePath - PackagePath to the generator npm package (optional)
-     * @param {String}          [resolved] - The file path to the generator (used only if generator is a module)
+     * @param meta
+     * @param generator - A generator module or a module path
      */
-    add(namespace, generator, resolved, packagePath) {
-        if (typeof generator === 'string') {
-            this._storeAsPath(namespace, generator, packagePath);
-            return;
+    add(meta, Generator) {
+        if (typeof meta.resolved === 'string') {
+            meta.resolved = extname(meta.resolved) ? join(meta.resolved) : join(meta.resolved, 'index.js');
         }
-        this._storeAsModule(namespace, generator, resolved, packagePath);
-    }
-    _storeAsPath(namespace, resolvedPath, packagePath) {
-        const importGenerator = () => requireOrImport(resolvedPath);
-        this._meta[namespace] = {
-            resolved: resolvedPath,
-            namespace,
-            packagePath,
-            importGenerator,
+        if (meta.packagePath) {
+            meta.packagePath = join(meta.packagePath);
+        }
+        let importModule;
+        if (!Generator) {
+            if (!meta.resolved) {
+                throw new Error(`Generator Stub or resolved path is required for ${meta.namespace}`);
+            }
+            importModule = async () => import(pathToFileURL(meta.resolved).href);
+        }
+        let importPromise;
+        const importGenerator = async () => {
+            if (importPromise) {
+                Generator = await importPromise;
+            }
+            if (importModule && !Generator) {
+                importPromise = importModule();
+                Generator = await importPromise;
+            }
+            const factory = this.getFactory(Generator);
+            if (typeof factory === 'function') {
+                importPromise = factory(this.env);
+                Generator = await importPromise;
+            }
+            return this._getGenerator(Generator, meta);
         };
-    }
-    _storeAsModule(namespace, Generator, resolved, packagePath) {
-        const importGenerator = () => Generator;
-        this._meta[namespace] = {
-            resolved,
-            namespace,
-            packagePath,
+        const instantiate = async (args = [], options = {}) => this.env.instantiate(await importGenerator(), { generatorArgs: args, generatorOptions: options });
+        const instantiateHelp = async () => instantiate([], { help: true });
+        const { packageNamespace } = toNamespace(meta.namespace) ?? {};
+        const generatorMeta = {
+            ...meta,
             importGenerator,
+            importModule,
+            instantiate,
+            instantiateHelp,
+            packageNamespace,
         };
+        this._meta[meta.namespace] = generatorMeta;
+        if (packageNamespace) {
+            this.addPackageNamespace(packageNamespace);
+            if (meta.packagePath) {
+                this.addPackage(packageNamespace, meta.packagePath);
+            }
+        }
+        return generatorMeta;
     }
     /**
      * Get the module registered under the given namespace
@@ -54,18 +82,7 @@ class Store {
      * @return {Module}
      */
     async get(namespace) {
-        const meta = this.getMeta(namespace);
-        if (!meta) {
-            return;
-        }
-        const { importGenerator, ...additionalMeta } = meta;
-        const maybeGenerator = importGenerator();
-        if (maybeGenerator.then) {
-            const esmGenerator = await maybeGenerator;
-            return [esmGenerator, additionalMeta];
-        }
-        Object.assign(maybeGenerator, additionalMeta);
-        return maybeGenerator;
+        return this.getMeta(namespace)?.importGenerator();
     }
     /**
      * Get the module registered under the given namespace
@@ -123,7 +140,7 @@ class Store {
      * Store a package ns
      * @param {String} packageNS - The key under which the generator can be retrieved
      */
-    addPackageNS(packageNS) {
+    addPackageNamespace(packageNS) {
         if (!this._packagesNS.includes(packageNS)) {
             this._packagesNS.push(packageNS);
         }
@@ -132,9 +149,21 @@ class Store {
      * Get the stored packages namespaces.
      * @return {Array} Stored packages namespaces.
      */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     getPackagesNS() {
         return this._packagesNS;
     }
+    getFactory(module) {
+        // CJS is imported in default, for backward compatibility we support a Generator exported as `module.exports = { default }`
+        return module.createGenerator ?? module.default?.createGenerator ?? module.default?.default?.createGenerator;
+    }
+    _getGenerator(module, meta) {
+        // eslint-disable-next-line  @typescript-eslint/naming-convention
+        const Generator = module.default?.default ?? module.default ?? module;
+        if (typeof Generator !== 'function') {
+            throw new TypeError("The generator doesn't provides a constructor.");
+        }
+        Object.assign(Generator, meta);
+        return Generator;
+    }
 }
-export default Store;
-//# sourceMappingURL=store.js.map

package/dist/util/command.d.ts

@@ -0,0 +1,34 @@
+import { Command, Option } from 'commander';
+import type BaseEnvironment from '../environment-base.js';
+export default class YeomanCommand extends Command {
+    env?: BaseEnvironment;
+    createCommand(name?: string): YeomanCommand;
+    /**
+     * Override addOption to register a negative alternative for every option.
+     * @param {Option} option
+     * @return {YeomanCommand} this;
+     */
+    addOption(option: Option): this;
+    /**
+     * Load Generator options into a commander instance.
+     *
+     * @param {Generator} generator - Generator
+     * @return {Command} return command
+     */
+    registerGenerator(generator: any): this;
+    /**
+     * Register arguments using generator._arguments structure.
+     * @param {object[]} generatorArgs
+     * @return {YeomanCommand} this;
+     */
+    addGeneratorArguments(generatorArgs?: any[]): this;
+    /**
+     * Register options using generator._options structure.
+     * @param {object} options
+     * @param {string} blueprintOptionDescription - description of the blueprint that adds the option
+     * @return {YeomanCommand} this;
+     */
+    addGeneratorOptions(options: Record<string, any>): this;
+    _addGeneratorOption(optionName: string, optionDefinition: any, additionalDescription?: string): any;
+}
+export declare const addEnvironmentOptions: (command?: YeomanCommand) => YeomanCommand;