yeoman-environment 4.4.3 → 5.0.0-beta.1

package/dist/environment-base.js

@@ -5,73 +5,74 @@ import process from 'node:process';
 import { realpathSync } from 'node:fs';
 import { QueuedAdapter } from '@yeoman/adapter';
 import { create as createMemFs } from 'mem-fs';
+import {} from 'mem-fs-editor';
 import { FlyRepository } from 'fly-import';
 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 {} from '@yeoman/conflicter';
 import { defaults, pick } from 'lodash-es';
-import { ComposedStore } from './composed-store.js';
-import Store from './store.js';
-import { asNamespace, defaultLookups } from './util/namespace.js';
-import { lookupGenerators } from './generator-lookup.js';
-import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from './constants.js';
-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 { ComposedStore } from "./composed-store.js";
+import Store from "./store.js";
+import { asNamespace, defaultLookups } from "./util/namespace.js";
+import { lookupGenerators } from "./generator-lookup.js";
+import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from "./constants.js";
+import { resolveModulePath } from "./util/resolve.js";
+import { commitSharedFsTask } from "./commit.js";
+import { packageManagerInstallTask } from "./package-manager.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 = (firstArg, generatorOptions) => {
+    // First argument can be an array of string, a string, a ComposeOptions, a GeneratorOptions, old variant of ComposeOptions.
+    if (Array.isArray(firstArg) || typeof firstArg === 'string') {
+        return { generatorArgs: splitArgumentsFromString(firstArg), generatorOptions };
     }
-    if (args !== undefined) {
-        if ('generatorOptions' in args || 'generatorArgs' in args) {
-            return args;
+    if (firstArg !== undefined) {
+        if ('generatorOptions' in firstArg || 'generatorArgs' in firstArg) {
+            return firstArg;
         }
-        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 firstArg || 'arguments' in firstArg || 'args' in firstArg) {
+            // Backward compatibility
+            const { args: insideArguments, arguments: generatorArguments = insideArguments, options: generatorOptions, ...remainingOptions } = firstArg;
+            return { generatorArgs: splitArgumentsFromString(generatorArguments), generatorOptions: generatorOptions ?? remainingOptions };
         }
     }
-    return { generatorOptions: options };
+    return { generatorOptions };
 };
 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 +103,7 @@ export default class EnvironmentBase extends EventEmitter {
     experimental;
     _rootGenerator;
     compatibilityMode;
+    contextStore = new Map();
     constructor(options = {}) {
         super();
         this.setMaxListeners(100);
@@ -131,7 +133,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 +149,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;
                 }),
             ]);
@@ -157,7 +159,7 @@ export default class EnvironmentBase extends EventEmitter {
      * @param   namespaceOrPath
      * @return the generator meta registered under the namespace
      */
-    async findMeta(namespaceOrPath) {
+    findMeta(namespaceOrPath) {
         // Stop the recursive search if nothing is left
         if (!namespaceOrPath) {
             return;
@@ -172,12 +174,14 @@ export default class EnvironmentBase extends EventEmitter {
             return maybeMeta;
         }
         try {
-            const resolved = await resolveModulePath(namespaceOrPath);
+            const resolved = resolveModulePath(namespaceOrPath);
             if (resolved) {
                 return this.store.add({ resolved, namespace: this.namespace(resolved) });
             }
         }
-        catch { }
+        catch {
+            // ignore error
+        }
         return undefined;
     }
     /**
@@ -190,71 +194,53 @@ export default class EnvironmentBase extends EventEmitter {
      * @param   namespaceOrPath
      * @return the generator registered under the namespace
      */
-    async get(namespaceOrPath) {
-        const meta = await this.findMeta(namespaceOrPath);
-        return meta?.importGenerator();
+    get(namespaceOrPath) {
+        return this.findMeta(namespaceOrPath)?.importGenerator();
     }
-    async create(namespaceOrPath, ...args) {
-        let constructor;
+    create(namespaceOrPath, ...arguments_) {
         const namespace = typeof namespaceOrPath === 'string' ? toNamespace(namespaceOrPath) : undefined;
         const checkGenerator = (Generator) => {
             const generatorNamespace = Generator?.namespace;
-            if (namespace && generatorNamespace !== namespace.namespace && generatorNamespace !== UNKNOWN_NAMESPACE) {
+            if (namespace && generatorNamespace && generatorNamespace !== namespace.namespace && generatorNamespace !== UNKNOWN_NAMESPACE) {
                 // Update namespace object in case of aliased namespace.
                 try {
-                    namespace.namespace = Generator.namespace;
+                    namespace.namespace = generatorNamespace;
                 }
                 catch {
                     // Invalid namespace can be aliased to a valid one.
                 }
             }
             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);
-        }
         if (typeof namespaceOrPath === 'string') {
-            const meta = await this.findMeta(namespaceOrPath);
-            constructor = await meta?.importGenerator();
+            const meta = this.findMeta(namespaceOrPath);
+            const constructor = meta?.importGenerator();
             if (namespace && !constructor) {
                 // Await this.lookupLocalNamespaces(namespace);
                 // constructor = await this.get(namespace);
             }
-            if (constructor) {
-                constructor._meta = meta;
+            if (constructor && 'then' in constructor) {
+                return constructor.then(g => {
+                    return this.instantiate(checkGenerator(g), ...arguments_);
+                });
             }
+            return this.instantiate(checkGenerator(constructor), ...arguments_);
         }
         else {
-            constructor = namespaceOrPath;
+            return this.instantiate(checkGenerator(namespaceOrPath), ...arguments_);
         }
-        return this.instantiate(checkGenerator(constructor), ...args);
     }
-    async instantiate(constructor, ...args) {
-        const composeOptions = args.length > 0 ? getInstantiateOptions(...args) : {};
+    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 ?? [], {
@@ -269,12 +255,12 @@ export default class EnvironmentBase extends EventEmitter {
             ...environmentOptions,
         };
         if (!composeOptions.generatorOptions?.help && generator._postConstruct) {
-            await generator._postConstruct();
+            return Promise.resolve(generator._postConstruct()).then(() => generator);
         }
         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}`);
@@ -339,10 +325,12 @@ export default class EnvironmentBase extends EventEmitter {
                 await generator.queueTasks();
                 return;
             }
-            if (!generator.options.forwardErrorToEnvironment) {
-                generator.on('error', (error) => this.emit('error', error));
+            // Backward compatibility
+            const oldGenerator = generator;
+            if (!oldGenerator.options.forwardErrorToEnvironment) {
+                oldGenerator.on('error', (error) => this.emit('error', error));
             }
-            generator.promise = generator.run();
+            oldGenerator.promise = oldGenerator.run();
         };
         if (schedule) {
             this.queueTask('environment:run', async () => runGenerator());
@@ -366,20 +354,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 +487,6 @@ export default class EnvironmentBase extends EventEmitter {
         if (!meta) {
             return;
         }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return { ...meta };
     }
     alias(match, value) {
@@ -513,7 +500,7 @@ export default class EnvironmentBase extends EventEmitter {
         if (typeof match !== 'string') {
             throw new TypeError('string is required');
         }
-        const aliases = [...this.aliases].reverse();
+        const aliases = [...this.aliases].toReversed();
         return aliases.reduce((resolved, alias) => {
             if (!alias.match.test(resolved)) {
                 return resolved;
@@ -564,7 +551,8 @@ export default class EnvironmentBase extends EventEmitter {
         return new Promise((resolve, reject) => {
             Object.assign(this.options, removePropertiesWithNullishValues(pick(options, ['skipInstall', 'nodePackageManager'])));
             this.logCwd = options.logCwd ?? this.logCwd;
-            this.conflicterOptions = pick(defaults({}, this.options, options), ['force', 'bail', 'ignoreWhitespace', 'dryRun', 'skipYoResolve']);
+            const conflicterOptionsProperties = ['force', 'bail', 'ignoreWhitespace', 'dryRun', 'skipYoResolve'];
+            this.conflicterOptions = defaults({}, pick(this.options, conflicterOptionsProperties), pick(options, conflicterOptionsProperties));
             this.conflicterOptions.cwd = this.logCwd;
             this.queueCommit();
             this.queueTask('install', () => {
@@ -695,4 +683,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

@@ -1,6 +1,6 @@
-import type { BaseGeneratorConstructor } from '@yeoman/types';
-import { type LookupOptions } from './generator-lookup.js';
-import EnvironmentBase, { type EnvironmentOptions } from './environment-base.js';
+import type { BaseGeneratorConstructor, BaseGeneratorOptions, GeneratorEnvironmentOptions } from '@yeoman/types';
+import { type LookupOptions } from './generator-lookup.ts';
+import EnvironmentBase, { type EnvironmentOptions } from './environment-base.ts';
 declare class FullEnvironment extends EnvironmentBase {
     constructor(options?: EnvironmentOptions);
     /**
@@ -14,7 +14,7 @@ declare class FullEnvironment extends EnvironmentBase {
      *
      * @param {Object} options
      */
-    loadSharedOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "skipInstall" | "forceInstall" | "skipCache" | "skipLocalCache" | "skipParseOptions" | "localConfigOnly" | "askAnswered">;
+    loadSharedOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "askAnswered" | "skipInstall" | "forceInstall" | "skipCache" | "skipLocalCache" | "skipParseOptions" | "localConfigOnly">;
     /**
      * @protected
      * Outputs the general help and usage. Optionally, if generators have been
@@ -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.
@@ -107,10 +107,7 @@ declare class FullEnvironment extends EnvironmentBase {
      * on the provided arguments, options and the list of registered generators.
      *
      * When the environment was unable to resolve a generator, an error is raised.
-     *
-     * @param {String|Array} args
-     * @param {Object}       [options]
      */
-    run(args?: string[], options?: any): Promise<void>;
+    run(arguments_?: string | string[], options?: EnvironmentOptions & BaseGeneratorOptions & Partial<GeneratorEnvironmentOptions>): Promise<void>;
 }
 export default FullEnvironment;

package/dist/environment-full.js

@@ -3,10 +3,11 @@ 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 YeomanCommand from './util/command.js';
-import EnvironmentBase from './environment-base.js';
-import { splitArgsFromString } from './util/util.js';
+import { valid } from 'semver';
+import {} from "./generator-lookup.js";
+import YeomanCommand from "./util/command.js";
+import EnvironmentBase, {} from "./environment-base.js";
+import { splitArgsFromString as splitArgumentsFromString } from "./util/util.js";
 class FullEnvironment extends EnvironmentBase {
     constructor(options = {}, adapterCompat) {
         if (adapterCompat) {
@@ -138,7 +139,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 +157,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.parse(arguments_, { from: 'user' });
         return this.run([namespace.namespace, ...namespaceCommand.args], {
             ...namespaceCommand.opts(),
         });
@@ -164,21 +165,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;
         }
@@ -286,14 +288,10 @@ class FullEnvironment extends EnvironmentBase {
      * on the provided arguments, options and the list of registered generators.
      *
      * When the environment was unable to resolve a generator, an error is raised.
-     *
-     * @param {String|Array} args
-     * @param {Object}       [options]
      */
-    async run(args, options) {
-        args = Array.isArray(args) ? args : splitArgsFromString(args);
-        options = { ...options };
-        let name = args.shift();
+    async run(arguments_, options = {}) {
+        arguments_ = Array.isArray(arguments_) ? arguments_ : splitArgumentsFromString(arguments_);
+        let name = arguments_.shift();
         if (!name) {
             throw new Error('Must provide at least one argument, the generator namespace to invoke.');
         }
@@ -305,18 +303,17 @@ class FullEnvironment extends EnvironmentBase {
             try {
                 await this.prepareEnvironment(name);
             }
-            catch { }
+            catch {
+                // ignore error
+            }
         }
         const generator = await this.create(name, {
-            generatorArgs: args,
-            generatorOptions: {
-                ...options,
-                initialGenerator: true,
-            },
+            generatorArgs: arguments_,
+            generatorOptions: options,
         });
         if (options.help) {
             console.log(generator.help());
-            return undefined;
+            return;
         }
         return this.runGenerator(generator);
     }

package/dist/generator-lookup.d.ts

@@ -1,5 +1,5 @@
-import { type LookupOptions as LookupOptionsApi } from '@yeoman/types';
-import { type ModuleLookupOptions } from './module-lookup.js';
+import type { LookupOptions as LookupOptionsApi } from '@yeoman/types';
+import { type ModuleLookupOptions } from './module-lookup.ts';
 export type LookupOptions = LookupOptionsApi & ModuleLookupOptions & {
     lookups?: string[];
 };

package/dist/generator-lookup.js

@@ -1,8 +1,8 @@
 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 { asNamespace, defaultLookups } from './util/namespace.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'];
 /**
  * Search for generators and their sub generators.
@@ -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,12 +64,12 @@ 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);
     options.packagePatterns = options.packagePatterns ?? [ns.generatorHint];
-    options.npmPaths = options.npmPaths ?? getNpmPaths({ localOnly: options.localOnly }).reverse();
+    options.npmPaths = options.npmPaths ?? getNpmPaths({ localOnly: options.localOnly }).toReversed();
     options.packagePatterns = options.packagePatterns ?? ['generator-*'];
     options.packagePaths = options.packagePaths ?? findPackagesIn(options.npmPaths, options.packagePatterns);
     let paths = options.singleResult ? undefined : [];
@@ -87,7 +87,7 @@ export function lookupGenerator(namespace, options) {
                 paths.push(returnPath);
             }
         }
-        return undefined;
+        return;
     });
     if (options.singleResult) {
         const generatorPath = paths;

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { type EnvironmentOptions } from './environment-base.js';
-import Environment from './environment-full.js';
-export { default } from './environment-full.js';
-export { default as EnvironmentBase } from './environment-base.js';
+import { type EnvironmentOptions } from './environment-base.ts';
+import Environment from './environment-full.ts';
+export { default } from './environment-full.ts';
+export { default as EnvironmentBase } from './environment-base.ts';
 export declare const createEnv: (options?: EnvironmentOptions) => Environment;
-export * from './commands.js';
-export * from './util/command.js';
-export * from './package-manager.js';
-export * from './commit.js';
-export { lookupGenerator } from './generator-lookup.js';
+export declare const enforceUpdate: () => void;
+export * from './commands.ts';
+export * from './util/command.ts';
+export * from './package-manager.ts';
+export * from './commit.ts';
+export { lookupGenerator } from './generator-lookup.ts';

package/dist/index.js

@@ -1,9 +1,12 @@
-import Environment from './environment-full.js';
-export { default } from './environment-full.js';
-export { default as EnvironmentBase } from './environment-base.js';
+import {} from "./environment-base.js";
+import Environment from "./environment-full.js";
+export { default } from "./environment-full.js";
+export { default as EnvironmentBase } from "./environment-base.js";
 export const createEnv = (options) => new Environment(options);
-export * from './commands.js';
-export * from './util/command.js';
-export * from './package-manager.js';
-export * from './commit.js';
-export { lookupGenerator } from './generator-lookup.js';
+// Backward compatibility
+export const enforceUpdate = () => { };
+export * from "./commands.js";
+export * from "./util/command.js";
+export * from "./package-manager.js";
+export * from "./commit.js";
+export { lookupGenerator } from "./generator-lookup.js";

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): {