yeoman-environment 4.4.2 → 5.0.0-beta.0

package/dist/cli/index.js

@@ -3,8 +3,8 @@ import process from 'node:process';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import YeomanCommand, { addEnvironmentOptions } from '../util/command.js';
-import { createEnv } from '../index.js';
-import { printGroupedGenerator, environmentAction } from './utils.js';
+import { createEnv as createEnvironment } from '../index.js';
+import { environmentAction, printGroupedGenerator } from './utils.js';
 const program = new YeomanCommand();
 const packageJson = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json')).toString());
 program.version(packageJson.version).allowExcessArguments(false).enablePositionalOptions();
@@ -21,16 +21,16 @@ program
     .command('find')
     .description('Find installed generators')
     .action(async () => {
-    const env = createEnv();
-    printGroupedGenerator(await env.lookup());
+    const environment = createEnvironment();
+    printGroupedGenerator(await environment.lookup());
 });
 program
     .command('list')
     .description('List generators available to be used')
     .action(async () => {
-    const env = createEnv();
-    await env.lookup();
-    printGroupedGenerator(Object.values(env.getGeneratorsMeta()));
+    const environment = createEnvironment();
+    await environment.lookup();
+    printGroupedGenerator(Object.values(environment.getGeneratorsMeta()));
 });
 try {
     await program.parseAsync(process.argv);

package/dist/cli/utils.js

@@ -1,7 +1,7 @@
 import { requireNamespace } from '@yeoman/namespace';
 import { groupBy } from 'lodash-es';
 import createLogger from 'debug';
-import { createEnv } from '../index.js';
+import { createEnv as createEnvironment } from '../index.js';
 const debug = createLogger('yeoman:yoe');
 export const printGroupedGenerator = (generators) => {
     const grouped = groupBy(generators, 'packagePath');
@@ -27,8 +27,8 @@ export const environmentAction = async function (generatorNamespace, options, co
     if (!generatorNamespace) {
         return;
     }
-    const env = createEnv({ ...options, command: this });
-    this.env = env;
-    await env.lookupLocalPackages();
-    return env.execute(generatorNamespace, command.args.splice(1));
+    const environment = createEnvironment({ ...options, command: this });
+    this.env = environment;
+    await environment.lookupLocalPackages();
+    return environment.execute(generatorNamespace, command.args.splice(1));
 };

package/dist/commands.js

@@ -1,5 +1,5 @@
 import YeomanCommand, { addEnvironmentOptions } from './util/command.js';
-import { createEnv } from './index.js';
+import { createEnv as createEnvironment } from './index.js';
 /**
  * Prepare a commander instance for cli support.
  *
@@ -8,27 +8,26 @@ import { createEnv } from './index.js';
  * @return {Command} return command
  */
 export const prepareGeneratorCommand = async ({ command = addEnvironmentOptions(new YeomanCommand()), resolved, generator, namespace, }) => {
-    const env = createEnv();
+    const environment = createEnvironment();
     let meta;
     if (generator && namespace) {
-        meta = env.register(generator, { namespace, resolved });
+        meta = environment.register(generator, { namespace, resolved });
     }
     else if (resolved) {
-        meta = env.register(resolved, { namespace });
+        meta = environment.register(resolved, { namespace });
     }
     else {
         throw new Error(`A generator with namespace or a generator path is required`);
     }
-    command.env = env;
+    command.env = environment;
     command.registerGenerator(await meta.instantiateHelp());
     command.action(async function () {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let rootCommand = this;
         while (rootCommand.parent) {
             rootCommand = rootCommand.parent;
         }
         const generator = await meta.instantiate(this.args, this.opts());
-        await env.runGenerator(generator);
+        await environment.runGenerator(generator);
     });
     return command;
 };

package/dist/commit.d.ts

@@ -7,6 +7,6 @@ import { type MemFsEditorFile } from 'mem-fs-editor';
  */
 export declare const commitSharedFsTask: ({ adapter, conflicterOptions, sharedFs, }: {
     adapter: InputOutputAdapter;
-    conflicterOptions?: ConflicterOptions | undefined;
+    conflicterOptions?: ConflicterOptions;
     sharedFs: Store<MemFsEditorFile>;
 }) => Promise<void>;

package/dist/commit.js

@@ -1,6 +1,5 @@
 import { createConflicterTransform, createYoResolveTransform, forceYoFiles } from '@yeoman/conflicter';
 import createdLogger from 'debug';
-import { create as createMemFsEditor } from 'mem-fs-editor';
 import { createCommitTransform } from 'mem-fs-editor/transform';
 import { isFilePending } from 'mem-fs-editor/state';
 const debug = createdLogger('yeoman:environment:commit');
@@ -9,6 +8,5 @@ const debug = createdLogger('yeoman:environment:commit');
  */
 export const commitSharedFsTask = async ({ adapter, conflicterOptions, sharedFs, }) => {
     debug('Running commitSharedFsTask');
-    const editor = createMemFsEditor(sharedFs);
     await sharedFs.pipeline({ filter: (file) => isFilePending(file) || file.path.endsWith('.yo-resolve') }, createYoResolveTransform(), forceYoFiles(), createConflicterTransform(adapter, conflicterOptions), createCommitTransform());
 };

package/dist/composed-store.d.ts

@@ -1,4 +1,4 @@
-import type { Logger, BaseGenerator } from '@yeoman/types';
+import type { BaseGenerator, Logger } from '@yeoman/types';
 export declare class ComposedStore {
     private readonly log?;
     private readonly generators;

package/dist/composed-store.js

@@ -68,10 +68,10 @@ export class ComposedStore {
             if (providedFeatures.length > 1) {
                 this.log?.info?.(`Multiple ${featureName} tasks found (${providedFeatures.map(({ generatorId }) => generatorId).join(', ')}). Using the first.`);
             }
-            const { generatorId, feature } = providedFeatures[0];
+            const [{ generatorId, feature }] = providedFeatures;
             debug(`Feature ${featureName} provided by ${generatorId}`);
             return feature;
         }
-        return undefined;
+        return;
     }
 }

package/dist/constants.js

@@ -1,6 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export const UNKNOWN_NAMESPACE = 'unknownnamespace';
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export const UNKNOWN_RESOLVED = 'unknown';
 export const defaultQueues = [
     'environment:run',

package/dist/environment-base.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import EventEmitter from 'node:events';
 import { QueuedAdapter, type TerminalAdapterOptions } from '@yeoman/adapter';
 import type { ApplyTransformsOptions, BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorConstructor, BaseGeneratorMeta, ComposeOptions, GeneratorMeta, GetGeneratorConstructor, InputOutputAdapter, InstantiateOptions, LookupGeneratorMeta } from '@yeoman/types';
@@ -54,6 +53,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     protected experimental: boolean;
     protected _rootGenerator?: BaseGenerator;
     protected compatibilityMode?: false | 'v4';
+    private contextStore;
     constructor(options?: EnvironmentOptions);
     findFeature(featureName: string): Array<{
         generatorId: string;
@@ -277,4 +277,9 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param  packagePath - The generator's package path
      */
     protected registerStub(Generator: any, namespace: string, resolved?: string, packagePath?: string): GeneratorMeta;
+    /**
+     * @experimental
+     * Get a map to store shared data, usually a generator root path to share a map by path.
+     */
+    getContextMap(key: string, factory?: () => Map<string, any>): Map<string, any>;
 }

package/dist/environment-base.js

@@ -10,7 +10,7 @@ import createdLogger from 'debug';
 // @ts-expect-error grouped-queue don't have types
 import GroupedQueue from 'grouped-queue';
 import { isFilePending } from 'mem-fs-editor/state';
-import { transform, filePipeline } from '@yeoman/transform';
+import { filePipeline, transform } from '@yeoman/transform';
 import { toNamespace } from '@yeoman/namespace';
 import chalk from 'chalk';
 import { defaults, pick } from 'lodash-es';
@@ -22,23 +22,21 @@ import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from './constants.
 import { resolveModulePath } from './util/resolve.js';
 import { commitSharedFsTask } from './commit.js';
 import { packageManagerInstallTask } from './package-manager.js';
-// eslint-disable-next-line import/order
-import { splitArgsFromString } from './util/util.js';
+import { splitArgsFromString as splitArgumentsFromString } from './util/util.js';
 const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/naming-convention
 const ENVIRONMENT_VERSION = require('../package.json').version;
 const debug = createdLogger('yeoman:environment');
-const getInstantiateOptions = (args, options) => {
-    if (Array.isArray(args) || typeof args === 'string') {
-        return { generatorArgs: splitArgsFromString(args), generatorOptions: options };
+const getInstantiateOptions = (arguments_, options) => {
+    if (Array.isArray(arguments_) || typeof arguments_ === 'string') {
+        return { generatorArgs: splitArgumentsFromString(arguments_), generatorOptions: options };
     }
-    if (args !== undefined) {
-        if ('generatorOptions' in args || 'generatorArgs' in args) {
-            return args;
+    if (arguments_ !== undefined) {
+        if ('generatorOptions' in arguments_ || 'generatorArgs' in arguments_) {
+            return arguments_;
         }
-        if ('options' in args || 'arguments' in args || 'args' in args) {
-            const { args: insideArgs, arguments: generatorArgs = insideArgs, options: generatorOptions, ...remainingOptions } = args;
-            return { generatorArgs: splitArgsFromString(generatorArgs), generatorOptions: generatorOptions ?? remainingOptions };
+        if ('options' in arguments_ || 'arguments' in arguments_ || 'args' in arguments_) {
+            const { args: insideArguments, arguments: generatorArguments = insideArguments, options: generatorOptions, ...remainingOptions } = arguments_;
+            return { generatorArgs: splitArgumentsFromString(generatorArguments), generatorOptions: generatorOptions ?? remainingOptions };
         }
     }
     return { generatorOptions: options };
@@ -46,32 +44,32 @@ const getInstantiateOptions = (args, options) => {
 const getComposeOptions = (...varargs) => {
     if (varargs.filter(Boolean).length === 0)
         return {};
-    const [args, options, composeOptions] = varargs;
-    if (typeof args === 'boolean') {
-        return { schedule: args };
+    const [arguments_, options, composeOptions] = varargs;
+    if (typeof arguments_ === 'boolean') {
+        return { schedule: arguments_ };
     }
-    let generatorArgs;
+    let generatorArguments;
     let generatorOptions;
-    if (args !== undefined) {
-        if (Array.isArray(args)) {
-            generatorArgs = args;
+    if (arguments_ !== undefined) {
+        if (Array.isArray(arguments_)) {
+            generatorArguments = arguments_;
         }
-        else if (typeof args === 'string') {
-            generatorArgs = splitArgsFromString(String(args));
+        else if (typeof arguments_ === 'string') {
+            generatorArguments = splitArgumentsFromString(String(arguments_));
         }
-        else if (typeof args === 'object') {
-            if ('generatorOptions' in args || 'generatorArgs' in args || 'schedule' in args) {
-                return args;
+        else if (typeof arguments_ === 'object') {
+            if ('generatorOptions' in arguments_ || 'generatorArgs' in arguments_ || 'schedule' in arguments_) {
+                return arguments_;
             }
-            generatorOptions = args;
+            generatorOptions = arguments_;
         }
     }
     if (typeof options === 'boolean') {
-        return { generatorArgs, generatorOptions, schedule: options };
+        return { generatorArgs: generatorArguments, generatorOptions, schedule: options };
     }
     generatorOptions = generatorOptions ?? options;
     if (typeof composeOptions === 'boolean') {
-        return { generatorArgs, generatorOptions, schedule: composeOptions };
+        return { generatorArgs: generatorArguments, generatorOptions, schedule: composeOptions };
     }
     return {};
 };
@@ -102,6 +100,7 @@ export default class EnvironmentBase extends EventEmitter {
     experimental;
     _rootGenerator;
     compatibilityMode;
+    contextStore = new Map();
     constructor(options = {}) {
         super();
         this.setMaxListeners(100);
@@ -131,7 +130,6 @@ export default class EnvironmentBase extends EventEmitter {
                 registry: arboristRegistry,
             },
         });
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         this.experimental = experimental || process.argv.includes('--experimental');
         this.alias(/^([^:]+)$/, '$1:app');
     }
@@ -148,6 +146,7 @@ export default class EnvironmentBase extends EventEmitter {
                 ...transformStreams,
                 transform(file => {
                     step('Completed', relative(this.logCwd, file.path));
+                    // eslint-disable-next-line unicorn/no-useless-undefined
                     return undefined;
                 }),
             ]);
@@ -177,7 +176,9 @@ export default class EnvironmentBase extends EventEmitter {
                 return this.store.add({ resolved, namespace: this.namespace(resolved) });
             }
         }
-        catch { }
+        catch {
+            // ignore error
+        }
         return undefined;
     }
     /**
@@ -194,7 +195,7 @@ export default class EnvironmentBase extends EventEmitter {
         const meta = await this.findMeta(namespaceOrPath);
         return meta?.importGenerator();
     }
-    async create(namespaceOrPath, ...args) {
+    async create(namespaceOrPath, ...arguments_) {
         let constructor;
         const namespace = typeof namespaceOrPath === 'string' ? toNamespace(namespaceOrPath) : undefined;
         const checkGenerator = (Generator) => {
@@ -209,33 +210,18 @@ export default class EnvironmentBase extends EventEmitter {
                 }
             }
             if (typeof Generator !== 'function') {
-                throw new TypeError(chalk.red(`You don't seem to have a generator with the name “${namespace?.generatorHint}” installed.`) +
-                    '\n' +
-                    'But help is on the way:\n\n' +
-                    'You can see available generators via ' +
-                    chalk.yellow('npm search yeoman-generator') +
-                    ' or via ' +
-                    chalk.yellow('http://yeoman.io/generators/') +
-                    '. \n' +
-                    'Install them with ' +
-                    chalk.yellow(`npm install ${namespace?.generatorHint}`) +
-                    '.\n\n' +
-                    'To see all your installed generators run ' +
-                    chalk.yellow('yo --generators') +
-                    '. ' +
-                    'Adding the ' +
-                    chalk.yellow('--help') +
-                    ' option will also show subgenerators. \n\n' +
-                    'If ' +
-                    chalk.yellow('yo') +
-                    ' cannot find the generator, run ' +
-                    chalk.yellow('yo doctor') +
-                    ' to troubleshoot your system.');
+                throw new TypeError(`${chalk.red(`You don't seem to have a generator with the name “${namespace?.generatorHint}” installed.`)}\n` +
+                    `But help is on the way:\n\n` +
+                    `You can see available generators via ${chalk.yellow('npm search yeoman-generator')} or via ${chalk.yellow('http://yeoman.io/generators/')}. \n` +
+                    `Install them with ${chalk.yellow(`npm install ${namespace?.generatorHint}`)}.\n\n` +
+                    `To see all your installed generators run ${chalk.yellow('yo --generators')}. ` +
+                    `Adding the ${chalk.yellow('--help')} option will also show subgenerators. \n\n` +
+                    `If ${chalk.yellow('yo')} cannot find the generator, run ${chalk.yellow('yo doctor')} to troubleshoot your system.`);
             }
             return Generator;
         };
         if (typeof namespaceOrPath !== 'string') {
-            return this.instantiate(checkGenerator(namespaceOrPath), ...args);
+            return this.instantiate(checkGenerator(namespaceOrPath), ...arguments_);
         }
         if (typeof namespaceOrPath === 'string') {
             const meta = await this.findMeta(namespaceOrPath);
@@ -251,10 +237,10 @@ export default class EnvironmentBase extends EventEmitter {
         else {
             constructor = namespaceOrPath;
         }
-        return this.instantiate(checkGenerator(constructor), ...args);
+        return this.instantiate(checkGenerator(constructor), ...arguments_);
     }
-    async instantiate(constructor, ...args) {
-        const composeOptions = args.length > 0 ? getInstantiateOptions(...args) : {};
+    async instantiate(constructor, ...arguments_) {
+        const composeOptions = arguments_.length > 0 ? getInstantiateOptions(...arguments_) : {};
         const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED, _meta } = constructor;
         const environmentOptions = { env: this, resolved, namespace };
         const generator = new constructor(composeOptions.generatorArgs ?? [], {
@@ -273,8 +259,8 @@ export default class EnvironmentBase extends EventEmitter {
         }
         return generator;
     }
-    async composeWith(generator, ...args) {
-        const options = getComposeOptions(...args);
+    async composeWith(generator, ...arguments_) {
+        const options = getComposeOptions(...arguments_);
         const { schedule: passedSchedule = true, ...instantiateOptions } = options;
         const generatorInstance = await this.create(generator, instantiateOptions);
         // Convert to function to keep type compatibility with old @yeoman/types where schedule is boolean only
@@ -323,7 +309,7 @@ export default class EnvironmentBase extends EventEmitter {
      * @return {Generator} The generator or singleton instance.
      */
     async queueGenerator(generator, queueOptions) {
-        const schedule = typeof queueOptions === 'boolean' ? queueOptions : queueOptions?.schedule ?? false;
+        const schedule = typeof queueOptions === 'boolean' ? queueOptions : (queueOptions?.schedule ?? false);
         const { added, identifier, generator: composedGenerator } = this.composedStore.addGenerator(generator);
         if (!added) {
             debug(`Using existing generator for namespace ${identifier}`);
@@ -366,20 +352,20 @@ export default class EnvironmentBase extends EventEmitter {
         this._rootGenerator = this._rootGenerator ?? generator;
         return this.start(generator.options);
     }
-    register(pathOrStub, meta, ...args) {
+    register(pathOrStub, meta, ...arguments_) {
         if (typeof pathOrStub === 'string') {
             if (typeof meta === 'object') {
                 return this.registerGeneratorPath(pathOrStub, meta.namespace, meta.packagePath);
             }
             // Backward compatibility
-            return this.registerGeneratorPath(pathOrStub, meta, ...args);
+            return this.registerGeneratorPath(pathOrStub, meta, ...arguments_);
         }
         if (pathOrStub) {
             if (typeof meta === 'object') {
                 return this.registerStub(pathOrStub, meta.namespace, meta.resolved, meta.packagePath);
             }
             // Backward compatibility
-            return this.registerStub(pathOrStub, meta, ...args);
+            return this.registerStub(pathOrStub, meta, ...arguments_);
         }
         throw new TypeError('You must provide a generator name to register.');
     }
@@ -499,7 +485,6 @@ export default class EnvironmentBase extends EventEmitter {
         if (!meta) {
             return;
         }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return { ...meta };
     }
     alias(match, value) {
@@ -695,4 +680,16 @@ export default class EnvironmentBase extends EventEmitter {
         debug('Registered %s (%s) on package (%s)', namespace, resolved, packagePath);
         return meta;
     }
+    /**
+     * @experimental
+     * Get a map to store shared data, usually a generator root path to share a map by path.
+     */
+    getContextMap(key, factory = () => new Map()) {
+        if (this.contextStore.has(key)) {
+            return this.contextStore.get(key);
+        }
+        const context = factory();
+        this.contextStore.set(key, context);
+        return context;
+    }
 }

package/dist/environment-full.d.ts

@@ -62,7 +62,7 @@ declare class FullEnvironment extends EnvironmentBase {
      * @param {string} generatorNamespace
      * @param {string[]} args
      */
-    execute(generatorNamespace: string, args?: never[]): Promise<void>;
+    execute(generatorNamespace: string, arguments_?: never[]): Promise<void>;
     requireGenerator(namespace: string): Promise<BaseGeneratorConstructor | undefined>;
     /**
      * Install generators at the custom local repository and register.
@@ -111,6 +111,6 @@ declare class FullEnvironment extends EnvironmentBase {
      * @param {String|Array} args
      * @param {Object}       [options]
      */
-    run(args?: string[], options?: any): Promise<void>;
+    run(arguments_?: string[], options?: any): Promise<void>;
 }
 export default FullEnvironment;

package/dist/environment-full.js

@@ -3,10 +3,10 @@ import { join, resolve } from 'node:path';
 import { requireNamespace, toNamespace } from '@yeoman/namespace';
 import { flyImport } from 'fly-import';
 import { defaults, pick, uniq } from 'lodash-es';
-import semver from 'semver';
+import { valid } from 'semver';
 import YeomanCommand from './util/command.js';
 import EnvironmentBase from './environment-base.js';
-import { splitArgsFromString } from './util/util.js';
+import { splitArgsFromString as splitArgumentsFromString } from './util/util.js';
 class FullEnvironment extends EnvironmentBase {
     constructor(options = {}, adapterCompat) {
         if (adapterCompat) {
@@ -138,7 +138,7 @@ class FullEnvironment extends EnvironmentBase {
      * @param {string} generatorNamespace
      * @param {string[]} args
      */
-    async execute(generatorNamespace, args = []) {
+    async execute(generatorNamespace, arguments_ = []) {
         const namespace = requireNamespace(generatorNamespace);
         if (!(await this.get(namespace.namespace))) {
             await this.lookup({
@@ -156,7 +156,7 @@ class FullEnvironment extends EnvironmentBase {
         // Instantiate the generator for options
         const generator = await this.create(namespace.namespace, { generatorArgs: [], generatorOptions: { help: true } });
         namespaceCommand.registerGenerator(generator);
-        namespaceCommand._parseCommand([], args);
+        namespaceCommand._parseCommand([], arguments_);
         return this.run([namespace.namespace, ...namespaceCommand.args], {
             ...namespaceCommand.opts(),
         });
@@ -164,21 +164,22 @@ class FullEnvironment extends EnvironmentBase {
     async requireGenerator(namespace) {
         if (namespace === undefined) {
             try {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
-                const { default: Generator } = await import('yeoman-generator'); // eslint-disable-line @typescript-eslint/naming-convention
+                // eslint-disable-next-line import-x/no-unresolved
+                const { default: Generator } = await import('yeoman-generator');
                 return Generator;
             }
-            catch { }
-            // eslint-disable-next-line @typescript-eslint/naming-convention
+            catch {
+                // ignore error
+            }
             const { default: Generator } = await flyImport('yeoman-generator');
             return Generator;
         }
         // Namespace is a version
-        if (semver.valid(namespace)) {
+        if (valid(namespace)) {
             // Create a hash to install any version range in the local repository
             const hash = createHash('shake256', { outputLength: 2 }).update(namespace, 'utf8').digest('hex');
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             const { default: Generator } = await flyImport(`@yeoman/generator-impl-${hash}@npm:yeoman-generator@${namespace}`);
             return Generator;
         }
@@ -290,10 +291,10 @@ class FullEnvironment extends EnvironmentBase {
      * @param {String|Array} args
      * @param {Object}       [options]
      */
-    async run(args, options) {
-        args = Array.isArray(args) ? args : splitArgsFromString(args);
+    async run(arguments_, options) {
+        arguments_ = Array.isArray(arguments_) ? arguments_ : splitArgumentsFromString(arguments_);
         options = { ...options };
-        let name = args.shift();
+        let name = arguments_.shift();
         if (!name) {
             throw new Error('Must provide at least one argument, the generator namespace to invoke.');
         }
@@ -305,10 +306,12 @@ class FullEnvironment extends EnvironmentBase {
             try {
                 await this.prepareEnvironment(name);
             }
-            catch { }
+            catch {
+                // ignore error
+            }
         }
         const generator = await this.create(name, {
-            generatorArgs: args,
+            generatorArgs: arguments_,
             generatorOptions: {
                 ...options,
                 initialGenerator: true,
@@ -316,7 +319,7 @@ class FullEnvironment extends EnvironmentBase {
         });
         if (options.help) {
             console.log(generator.help());
-            return undefined;
+            return;
         }
         return this.runGenerator(generator);
     }

package/dist/generator-lookup.js

@@ -1,7 +1,7 @@
 import { extname, isAbsolute, join, posix } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { requireNamespace, toNamespace } from '@yeoman/namespace';
-import { moduleLookupSync, getNpmPaths, findPackagesIn } from './module-lookup.js';
+import { findPackagesIn, getNpmPaths, moduleLookupSync } from './module-lookup.js';
 import { asNamespace, defaultLookups } from './util/namespace.js';
 export const defaultExtensions = ['.ts', '.cts', '.mts', '.js', '.cjs', '.mjs'];
 /**
@@ -32,7 +32,7 @@ export async function lookupGenerators(options = {}, register) {
     const { lookups = defaultLookups } = options;
     options = {
         // Js generators should be after, last will override registered one.
-        filePatterns: lookups.flatMap(prefix => defaultExtensions.map(ext => `${prefix}/*/index${ext}`)),
+        filePatterns: lookups.flatMap(prefix => defaultExtensions.map(extension => `${prefix}/*/index${extension}`)),
         filterPaths: false,
         packagePatterns: ['generator-*'],
         reverse: !options.singleResult,
@@ -48,7 +48,7 @@ export async function lookupGenerators(options = {}, register) {
                 return filePath;
             }
         }
-        return undefined;
+        return;
     });
 }
 /**
@@ -64,7 +64,7 @@ export async function lookupGenerators(options = {}, register) {
  * @return {String} generator
  */
 export function lookupGenerator(namespace, options) {
-    options = typeof options === 'boolean' ? { localOnly: options } : options ?? {};
+    options = typeof options === 'boolean' ? { localOnly: options } : (options ?? {});
     options.singleResult = options.singleResult ?? true;
     options.filePatterns = options.filePatterns ?? defaultLookups.map(prefix => join(prefix, '*/index.{js,ts}'));
     const ns = requireNamespace(namespace);
@@ -87,7 +87,7 @@ export function lookupGenerator(namespace, options) {
                 paths.push(returnPath);
             }
         }
-        return undefined;
+        return;
     });
     if (options.singleResult) {
         const generatorPath = paths;

package/dist/module-lookup.d.ts

@@ -21,7 +21,7 @@ export type ModuleLookupOptions = {
 /**
  * Search for npm packages.
  */
-export declare function moduleLookupSync(options: ModuleLookupOptions, find: (arg: {
+export declare function moduleLookupSync(options: ModuleLookupOptions, find: (argument: {
     files: string[];
     packagePath: string;
 }) => string | undefined): {

package/dist/module-lookup.js

@@ -3,16 +3,14 @@ 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 { compact, uniq } 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;
@@ -156,8 +154,8 @@ function getLocalNpmPaths() {
     process
         .cwd()
         .split(sep)
-        .forEach((part, i, parts) => {
-        let lookup = join(...parts.slice(0, i + 1), 'node_modules');
+        .forEach((part, index, parts) => {
+        let lookup = join(...parts.slice(0, index + 1), 'node_modules');
         if (!win32) {
             lookup = `/${lookup}`;
         }
@@ -207,15 +205,13 @@ function getGlobalNpmPaths(filterPaths = true) {
     // 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' });
+    const yarnBase = execaOutput('yarn', ['global', 'dir']);
     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',
-    });
+    const globalInstall = execaOutput('npm', ['root', '-g']);
     if (globalInstall) {
         paths.push(resolve(globalInstall));
     }

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import type { BaseEnvironment, GetGeneratorConstructor, GeneratorMeta, BaseGeneratorMeta } from '@yeoman/types';
+import type { BaseEnvironment, BaseGeneratorMeta, GeneratorMeta, GetGeneratorConstructor } from '@yeoman/types';
 /**
  * The Generator store
  * This is used to store generator (npm packages) reference and instantiate them when
@@ -7,11 +7,11 @@ import type { BaseEnvironment, GetGeneratorConstructor, GeneratorMeta, BaseGener
  * @private
  */
 export default class Store {
-    private readonly env;
+    private readonly environment;
     private readonly _meta;
     private readonly _packagesPaths;
     private readonly _packagesNS;
-    constructor(env: BaseEnvironment);
+    constructor(environment: BaseEnvironment);
     /**
      * Store a module under the namespace key
      * @param meta

package/dist/store.js

@@ -13,15 +13,14 @@ const require = createRequire(import.meta.url);
  * @private
  */
 export default class Store {
-    env;
+    environment;
     _meta = {};
     // Store packages paths by ns
     _packagesPaths = {};
     // Store packages ns
-    // eslint-disable-next-line @typescript-eslint/naming-convention
     _packagesNS = [];
-    constructor(env) {
-        this.env = env;
+    constructor(environment) {
+        this.environment = environment;
     }
     /**
      * Store a module under the namespace key
@@ -65,12 +64,12 @@ export default class Store {
             }
             const factory = this.getFactory(Generator);
             if (typeof factory === 'function') {
-                importPromise = factory(this.env);
+                importPromise = factory(this.environment);
                 Generator = await importPromise;
             }
             return this._getGenerator(Generator, meta);
         };
-        const instantiate = async (args = [], options = {}) => this.env.instantiate(await importGenerator(), { generatorArgs: args, generatorOptions: options });
+        const instantiate = async (arguments_ = [], options = {}) => this.environment.instantiate(await importGenerator(), { generatorArgs: arguments_, generatorOptions: options });
         const instantiateHelp = async () => instantiate([], { help: true });
         const { packageNamespace } = toNamespace(meta.namespace) ?? {};
         const generatorMeta = {
@@ -163,7 +162,6 @@ export default class Store {
      * Get the stored packages namespaces.
      * @return {Array} Stored packages namespaces.
      */
-    // eslint-disable-next-line @typescript-eslint/naming-convention
     getPackagesNS() {
         return this._packagesNS;
     }
@@ -172,10 +170,9 @@ export default class Store {
         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.");
+            throw new TypeError("The generator doesn't provide a constructor.");
         }
         Object.assign(Generator, meta);
         return Generator;

package/dist/util/command.d.ts

@@ -21,7 +21,7 @@ export default class YeomanCommand extends Command {
      * @param {object[]} generatorArgs
      * @return {YeomanCommand} this;
      */
-    addGeneratorArguments(generatorArgs?: any[]): this;
+    addGeneratorArguments(generatorArguments?: any[]): this;
     /**
      * Register options using generator._options structure.
      * @param {object} options

package/dist/util/command.js

@@ -39,17 +39,17 @@ export default class YeomanCommand extends Command {
      * @param {object[]} generatorArgs
      * @return {YeomanCommand} this;
      */
-    addGeneratorArguments(generatorArgs = []) {
-        if (!generatorArgs || generatorArgs.length === 0) {
+    addGeneratorArguments(generatorArguments = []) {
+        if (!generatorArguments || generatorArguments.length === 0) {
             return this;
         }
-        const args = generatorArgs
+        const arguments_ = generatorArguments
             .map(argument => {
-            const argName = argument.type === Array ? `${argument.name}...` : argument.name;
-            return argument.required ? `<${argName}>` : `[${argName}]`;
+            const argumentName = argument.type === Array ? `${argument.name}...` : argument.name;
+            return argument.required ? `<${argumentName}>` : `[${argumentName}]`;
         })
             .join(' ');
-        this.arguments(args);
+        this.arguments(arguments_);
         return this;
     }
     /**
@@ -67,7 +67,7 @@ export default class YeomanCommand extends Command {
     }
     _addGeneratorOption(optionName, optionDefinition, additionalDescription = '') {
         if (optionName === 'help') {
-            return undefined;
+            return;
         }
         const longOption = `--${optionName}`;
         const existingOption = this._findOption(longOption);

package/dist/util/namespace.js

@@ -1,6 +1,6 @@
 import { parse } from 'node:path';
 import slash from 'slash';
-import { findLast, escapeRegExp } from 'lodash-es';
+import { escapeRegExp, findLast } from 'lodash-es';
 export const defaultLookups = ['.', 'generators', 'lib/generators', 'dist/generators'];
 /**
  * Given a String `filepath`, tries to figure out the relative namespace.
@@ -31,7 +31,7 @@ export const asNamespace = (filepath, { lookups = defaultLookups }) => {
     // Ignore path before latest node_modules
     const nodeModulesPath = '/node_modules/';
     if (ns.includes(nodeModulesPath)) {
-        ns = ns.slice(ns.lastIndexOf(nodeModulesPath) + nodeModulesPath.length, ns.length);
+        ns = ns.slice(ns.lastIndexOf(nodeModulesPath) + nodeModulesPath.length);
     }
     // Cleanup extension and normalize path for differents OS
     const parsed = parse(ns);

package/dist/util/resolve.js

@@ -32,9 +32,11 @@ export async function resolveModulePath(specifier, resolvedOrigin) {
             return maybeResolved;
         }
         if (specStat.isDirectory()) {
-            return await locatePath(defaultExtensions.map(ext => `index${ext}`).map(file => join(maybeResolved, file)));
+            return await locatePath(defaultExtensions.map(extension => `index${extension}`).map(file => join(maybeResolved, file)));
         }
     }
-    catch { }
+    catch {
+        // ignore error
+    }
     throw new Error(`Error resolving ${specifier}`);
 }

package/dist/util/util.d.ts

@@ -1,7 +1,6 @@
-import { type SyncOptions } from 'execa';
-export declare const execaOutput: (cmg: string, args: string[], options: SyncOptions) => string | undefined;
+export declare const execaOutput: (cmg: string, arguments_: string[]) => string | undefined;
 /**
  * Two-step argument splitting function that first splits arguments in quotes,
  * and then splits up the remaining arguments if they are not part of a quote.
  */
-export declare function splitArgsFromString(argsString: string | string[]): string[];
+export declare function splitArgsFromString(argumentsString: string | string[]): string[];

package/dist/util/util.js

@@ -1,33 +1,35 @@
 import { execaSync } from 'execa';
-export const execaOutput = (cmg, args, options) => {
+export const execaOutput = (cmg, arguments_) => {
     try {
-        const result = execaSync(cmg, args, options);
-        if (!result.failed) {
-            return result.stdout;
+        const { failed, stdout } = execaSync(cmg, arguments_, { encoding: 'utf8' });
+        if (!failed) {
+            return stdout;
         }
     }
-    catch { }
-    return undefined;
+    catch {
+        // ignore error
+    }
+    return;
 };
 /**
  * Two-step argument splitting function that first splits arguments in quotes,
  * and then splits up the remaining arguments if they are not part of a quote.
  */
-export function splitArgsFromString(argsString) {
-    if (Array.isArray(argsString)) {
-        return argsString;
+export function splitArgsFromString(argumentsString) {
+    if (Array.isArray(argumentsString)) {
+        return argumentsString;
     }
     let result = [];
-    if (!argsString) {
+    if (!argumentsString) {
         return result;
     }
-    const quoteSeparatedArgs = argsString.split(/("[^"]*")/).filter(Boolean);
-    for (const arg of quoteSeparatedArgs) {
-        if (arg.includes('"')) {
-            result.push(arg.replaceAll('"', ''));
+    const quoteSeparatedArguments = argumentsString.split(/("[^"]*")/).filter(Boolean);
+    for (const argument of quoteSeparatedArguments) {
+        if (argument.includes('"')) {
+            result.push(argument.replaceAll('"', ''));
         }
         else {
-            result = result.concat(arg.trim().split(' '));
+            result = result.concat(argument.trim().split(' '));
         }
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "4.4.2",
+  "version": "5.0.0-beta.0",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",
@@ -23,7 +23,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.js",
-      "import": "./dist/index.js"
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -44,9 +44,9 @@
     "doc:fix": "sed -i -e 's:^[[:space:]]*<!--[[:space:]]*$::g' -e 's:^[[:space:]]*-->[[:space:]]*$::g' $npm_package_config_doc_path/global.html || true",
     "doc:generate": "jsdoc -c jsdoc.json -d $npm_package_config_doc_path",
     "doc:prettier": "prettier $npm_package_config_doc_path --write --ignore-path .prettierignore-doc",
-    "fix": "xo --fix",
+    "fix": "eslint --fix && prettier . --write",
     "prepare": "npm run build",
-    "pretest": "xo",
+    "pretest": "eslint && prettier . --check",
     "test": "c8 esmocha --forbid-only",
     "test-base": "c8 esmocha test/environment*.js test/store.js test/util.js test/adapter.js",
     "test-environment": "c8 esmocha test/environment.js",
@@ -57,45 +57,47 @@
     "doc_path": "./yeoman-environment-doc"
   },
   "dependencies": {
-    "@yeoman/adapter": "^1.4.0",
-    "@yeoman/conflicter": "^2.0.0-alpha.2",
-    "@yeoman/namespace": "^1.0.0",
-    "@yeoman/transform": "^1.2.0",
-    "@yeoman/types": "^1.1.1",
+    "@yeoman/adapter": "^2.1.1",
+    "@yeoman/conflicter": "^2.4.0",
+    "@yeoman/namespace": "^1.0.1",
+    "@yeoman/transform": "^2.1.0",
+    "@yeoman/types": "^1.6.0",
     "arrify": "^3.0.0",
-    "chalk": "^5.3.0",
-    "commander": "^11.1.0",
-    "debug": "^4.3.4",
-    "execa": "^8.0.1",
-    "fly-import": "^0.4.0",
-    "globby": "^14.0.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "debug": "^4.4.0",
+    "execa": "^9.5.3",
+    "fly-import": "^0.4.1",
+    "globby": "^14.1.0",
     "grouped-queue": "^2.0.0",
     "locate-path": "^7.2.0",
     "lodash-es": "^4.17.21",
-    "mem-fs": "^4.0.0",
-    "mem-fs-editor": "^11.0.0",
-    "semver": "^7.5.4",
+    "mem-fs": "^4.1.2",
+    "mem-fs-editor": "^11.1.4",
+    "semver": "^7.7.2",
     "slash": "^5.1.0",
     "untildify": "^5.0.0",
-    "which-package-manager": "^0.0.1"
+    "which-package-manager": "^1.0.1"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.9",
-    "@types/lodash-es": "^4.17.9",
-    "@types/semver": "^7.5.3",
-    "c8": "^10.1.2",
+    "@types/debug": "^4.1.12",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^18.19.100",
+    "@types/semver": "^7.7.0",
+    "@yeoman/eslint": "0.2.0",
+    "c8": "^10.1.3",
     "cpy-cli": "^5.0.0",
-    "esmocha": "^1.0.1",
-    "fs-extra": "^11.1.1",
-    "jsdoc": "^4.0.2",
-    "prettier": "3.0.3",
-    "prettier-plugin-packagejson": "^2.4.6",
-    "rimraf": "^5.0.5",
-    "sinon": "^19.0.2",
-    "sinon-test": "^3.1.5",
+    "eslint": "9.12.0",
+    "esmocha": "^3.0.0",
+    "fs-extra": "^11.3.0",
+    "jsdoc": "^4.0.4",
+    "prettier": "3.5.3",
+    "prettier-plugin-packagejson": "^2.5.12",
+    "rimraf": "^6.0.1",
+    "sinon": "^20.0.0",
+    "sinon-test": "^3.1.6",
     "strip-ansi": "^7.1.0",
-    "typescript": "5.2.2",
-    "xo": "0.56.0",
+    "typescript": "5.8.3",
     "yeoman-assert": "^3.1.1",
     "yeoman-environment": "file:./",
     "yeoman-generator-2": "npm:yeoman-generator@^2.0.5",
@@ -103,7 +105,14 @@
     "yeoman-generator-5": "npm:yeoman-generator@^5.10.0",
     "yeoman-generator-6": "npm:yeoman-generator@^6.0.1",
     "yeoman-generator-7": "npm:yeoman-generator@^7.0.0",
-    "yeoman-test": "^8.1.0"
+    "yeoman-test": "^10.1.0"
+  },
+  "peerDependencies": {
+    "@yeoman/types": "^1.1.1",
+    "mem-fs": "^4.0.0"
+  },
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
   },
   "overrides": {
     "yeoman-generator-2": {
@@ -163,15 +172,5 @@
     "yeoman-generator-6": {
       "yeoman-environment": "*"
     }
-  },
-  "peerDependencies": {
-    "@yeoman/types": "^1.1.1",
-    "mem-fs": "^4.0.0"
-  },
-  "acceptDependencies": {
-    "@yeoman/adapter": "^2.0.0"
-  },
-  "engines": {
-    "node": "^18.17.0 || >=20.5.0"
   }
 }