yeoman-environment 5.0.0-beta.0 → 5.0.0-beta.1

package/bin/bin.cjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 (async function () {
+  // eslint-disable-next-line import-x/extensions
   await import('../dist/cli/index.js');
 })();

package/dist/cli/index.js

@@ -2,9 +2,9 @@ import { readFileSync } from 'node:fs';
 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 as createEnvironment } from '../index.js';
-import { environmentAction, printGroupedGenerator } from './utils.js';
+import YeomanCommand, { addEnvironmentOptions } from "../util/command.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();

package/dist/cli/utils.d.ts

@@ -1,5 +1,5 @@
 import type { BaseGeneratorMeta } from '@yeoman/types';
-import type YeomanCommand from '../util/command.js';
+import type YeomanCommand from '../util/command.ts';
 export declare const printGroupedGenerator: (generators: BaseGeneratorMeta[]) => void;
 /**
  * @param {string} generatorNamespace

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 as createEnvironment } from '../index.js';
+import { createEnv as createEnvironment } from "../index.js";
 const debug = createLogger('yeoman:yoe');
 export const printGroupedGenerator = (generators) => {
     const grouped = groupBy(generators, 'packagePath');

package/dist/commands.d.ts

@@ -1,5 +1,5 @@
-import { type BaseGeneratorConstructor } from '@yeoman/types';
-import YeomanCommand from './util/command.js';
+import type { BaseGeneratorConstructor } from '@yeoman/types';
+import YeomanCommand from './util/command.ts';
 export type CommandPreparation = {
     resolved?: string;
     command?: YeomanCommand;

package/dist/commands.js

@@ -1,5 +1,5 @@
-import YeomanCommand, { addEnvironmentOptions } from './util/command.js';
-import { createEnv as createEnvironment } from './index.js';
+import YeomanCommand, { addEnvironmentOptions } from "./util/command.js";
+import { createEnv as createEnvironment } from "./index.js";
 /**
  * Prepare a commander instance for cli support.
  *

package/dist/commit.js

@@ -1,5 +1,6 @@
 import { createConflicterTransform, createYoResolveTransform, forceYoFiles } from '@yeoman/conflicter';
 import createdLogger from 'debug';
+import {} from 'mem-fs-editor';
 import { createCommitTransform } from 'mem-fs-editor/transform';
 import { isFilePending } from 'mem-fs-editor/state';
 const debug = createdLogger('yeoman:environment:commit');

package/dist/composed-store.d.ts

@@ -1,4 +1,5 @@
 import type { BaseGenerator, Logger } from '@yeoman/types';
+import type { InstallTask } from './package-manager.ts';
 export declare class ComposedStore {
     private readonly log?;
     private readonly generators;
@@ -7,8 +8,8 @@ export declare class ComposedStore {
     constructor({ log }?: {
         log?: Logger;
     });
-    get customCommitTask(): any;
-    get customInstallTask(): any;
+    get customCommitTask(): (() => Promise<void> | void) | undefined;
+    get customInstallTask(): InstallTask | undefined;
     getGenerators(): Record<string, BaseGenerator>;
     addGenerator(generator: BaseGenerator): {
         uniqueBy: any;
@@ -22,9 +23,9 @@ export declare class ComposedStore {
         uniqueBy?: undefined;
     };
     getUniqueByPathMap(root: string): Map<string, BaseGenerator>;
-    findFeature(featureName: string): Array<{
+    findFeature<T = unknown>(featureName: string): Array<{
         generatorId: string;
-        feature: any;
+        feature: T;
     }>;
     private findUniqueFeature;
 }

package/dist/composed-store.js

@@ -58,7 +58,7 @@ export class ComposedStore {
             .map(([generatorId, generator]) => {
             const { features = generator.getFeatures?.() } = generator;
             const feature = features?.[featureName];
-            return feature ? { generatorId, feature } : undefined;
+            return feature ? { generatorId, feature: feature } : undefined;
         })
             .filter(Boolean);
     }

package/dist/environment-base.d.ts

@@ -1,6 +1,6 @@
 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';
+import type { ApplyTransformsOptions, BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorConstructorMeta, BaseGeneratorMeta, ComposeOptions, GeneratorMeta, GetGeneratorConstructor, InputOutputAdapter, InstantiateOptions, LookupGeneratorMeta } from '@yeoman/types';
 import { type Store as MemFs } from 'mem-fs';
 import { type MemFsEditorFile } from 'mem-fs-editor';
 import { FlyRepository } from 'fly-import';
@@ -8,10 +8,11 @@ import GroupedQueue from 'grouped-queue';
 import { type FilePipelineTransform } from '@yeoman/transform';
 import { type YeomanNamespace } from '@yeoman/namespace';
 import { type ConflicterOptions } from '@yeoman/conflicter';
-import { ComposedStore } from './composed-store.js';
-import Store from './store.js';
-import type YeomanCommand from './util/command.js';
-import { type LookupOptions } from './generator-lookup.js';
+import { ComposedStore } from './composed-store.ts';
+import Store from './store.ts';
+import type YeomanCommand from './util/command.ts';
+import { type LookupOptions } from './generator-lookup.ts';
+import { type InstallTask } from './package-manager.ts';
 export type EnvironmentLookupOptions = LookupOptions & {
     /** Add a scope to the namespace if there is no scope */
     registerToScope?: string;
@@ -64,7 +65,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param   namespaceOrPath
      * @return the generator meta registered under the namespace
      */
-    findMeta(namespaceOrPath: string | YeomanNamespace): Promise<GeneratorMeta | undefined>;
+    findMeta(namespaceOrPath: string | YeomanNamespace): GeneratorMeta | undefined;
     /**
      * Get a single generator from the registered list of generators. The lookup is
      * based on generator's namespace, "walking up" the namespaces until a matching
@@ -75,7 +76,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param   namespaceOrPath
      * @return the generator registered under the namespace
      */
-    get<C extends BaseGeneratorConstructor = BaseGeneratorConstructor>(namespaceOrPath: string | YeomanNamespace): Promise<C | undefined>;
+    get<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | YeomanNamespace): Promise<(GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined> | ((GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined);
     /**
      * Create is the Generator factory. It takes a namespace to lookup and optional
      * hash of options, that lets you define `arguments` and `options` to
@@ -87,7 +88,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param instantiateOptions
      * @return The instantiated generator
      */
-    create<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | GetGeneratorConstructor<G>, instantiateOptions?: InstantiateOptions<G>): Promise<G>;
+    create<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | (GetGeneratorConstructor<G> & Partial<BaseGeneratorConstructorMeta>), instantiateOptions?: InstantiateOptions<G>): Promise<G>;
     /**
      * Instantiate a Generator with metadatas
      *
@@ -245,7 +246,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     watchForPackageManagerInstall({ cwd, queueTask, installTask, }?: {
         cwd?: string;
         queueTask?: boolean;
-        installTask?: (nodePackageManager: string | undefined, defaultTask: () => Promise<boolean>) => void | Promise<void>;
+        installTask?: InstallTask;
     }): void;
     /**
      * Start Environment queue

package/dist/environment-base.js

@@ -5,41 +5,44 @@ 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 { 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';
-import { splitArgsFromString as splitArgumentsFromString } 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);
 const ENVIRONMENT_VERSION = require('../package.json').version;
 const debug = createdLogger('yeoman:environment');
-const getInstantiateOptions = (arguments_, options) => {
-    if (Array.isArray(arguments_) || typeof arguments_ === 'string') {
-        return { generatorArgs: splitArgumentsFromString(arguments_), 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 (arguments_ !== undefined) {
-        if ('generatorOptions' in arguments_ || 'generatorArgs' in arguments_) {
-            return arguments_;
+    if (firstArg !== undefined) {
+        if ('generatorOptions' in firstArg || 'generatorArgs' in firstArg) {
+            return firstArg;
         }
-        if ('options' in arguments_ || 'arguments' in arguments_ || 'args' in arguments_) {
-            const { args: insideArguments, arguments: generatorArguments = insideArguments, options: generatorOptions, ...remainingOptions } = arguments_;
+        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)
@@ -156,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;
@@ -171,7 +174,7 @@ 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) });
             }
@@ -191,19 +194,17 @@ 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, ...arguments_) {
-        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.
@@ -220,26 +221,25 @@ export default class EnvironmentBase extends EventEmitter {
             }
             return Generator;
         };
-        if (typeof namespaceOrPath !== 'string') {
-            return this.instantiate(checkGenerator(namespaceOrPath), ...arguments_);
-        }
         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), ...arguments_);
     }
-    async instantiate(constructor, ...arguments_) {
+    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 };
@@ -255,7 +255,7 @@ 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;
     }
@@ -325,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());
@@ -498,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;
@@ -549,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', () => {

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
@@ -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(arguments_?: string[], options?: any): Promise<void>;
+    run(arguments_?: string | string[], options?: EnvironmentOptions & BaseGeneratorOptions & Partial<GeneratorEnvironmentOptions>): Promise<void>;
 }
 export default FullEnvironment;

package/dist/environment-full.js

@@ -4,9 +4,10 @@ import { requireNamespace, toNamespace } from '@yeoman/namespace';
 import { flyImport } from 'fly-import';
 import { defaults, pick, uniq } from 'lodash-es';
 import { valid } from 'semver';
-import YeomanCommand from './util/command.js';
-import EnvironmentBase from './environment-base.js';
-import { splitArgsFromString as splitArgumentsFromString } from './util/util.js';
+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) {
@@ -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([], arguments_);
+        namespaceCommand.parse(arguments_, { from: 'user' });
         return this.run([namespace.namespace, ...namespaceCommand.args], {
             ...namespaceCommand.opts(),
         });
@@ -287,13 +288,9 @@ 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(arguments_, options) {
+    async run(arguments_, options = {}) {
         arguments_ = Array.isArray(arguments_) ? arguments_ : splitArgumentsFromString(arguments_);
-        options = { ...options };
         let name = arguments_.shift();
         if (!name) {
             throw new Error('Must provide at least one argument, the generator namespace to invoke.');
@@ -312,10 +309,7 @@ class FullEnvironment extends EnvironmentBase {
         }
         const generator = await this.create(name, {
             generatorArgs: arguments_,
-            generatorOptions: {
-                ...options,
-                initialGenerator: true,
-            },
+            generatorOptions: options,
         });
         if (options.help) {
             console.log(generator.help());

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 { findPackagesIn, getNpmPaths, moduleLookupSync } 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.
@@ -69,7 +69,7 @@ export function lookupGenerator(namespace, options) {
     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 : [];

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.js

@@ -7,7 +7,7 @@ import { compact, uniq } from 'lodash-es';
 import { globbySync } from 'globby';
 import slash from 'slash';
 import createdLogger from 'debug';
-import { execaOutput } from './util/util.js';
+import { execaOutput } from "./util/util.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PROJECT_ROOT = join(__dirname, '..');
@@ -25,13 +25,13 @@ export function moduleLookupSync(options, find) {
     if (options.packagePaths) {
         options.packagePaths = arrify(options.packagePaths);
         if (options.reverse) {
-            options.packagePaths = options.packagePaths.reverse();
+            options.packagePaths = options.packagePaths.toReversed();
         }
     }
     else {
         options.npmPaths = options.npmPaths ?? getNpmPaths(options);
         if (options.reverse && Array.isArray(options.npmPaths)) {
-            options.npmPaths = options.npmPaths.reverse();
+            options.npmPaths = options.npmPaths.toReversed();
         }
         options.packagePatterns = arrify(options.packagePatterns ?? PACKAGE_NAME_PATTERN).map(packagePattern => slash(packagePattern));
         options.packagePaths = findPackagesIn(options.npmPaths, options.packagePatterns);
@@ -161,7 +161,7 @@ function getLocalNpmPaths() {
         }
         paths.push(lookup);
     });
-    return uniq(paths.reverse());
+    return uniq(paths.toReversed());
 }
 /**
  * Get the global npm lookup directories
@@ -203,12 +203,12 @@ function getGlobalNpmPaths(filterPaths = true) {
     // 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)
+    // eslint-disable-next-line unicorn/prefer-single-call
     paths.push(join(PROJECT_ROOT, '..'));
     // Get yarn global directory and infer the module paths from there
     const yarnBase = execaOutput('yarn', ['global', 'dir']);
     if (yarnBase) {
-        paths.push(resolve(yarnBase, 'node_modules'));
-        paths.push(resolve(yarnBase, '../link/'));
+        paths.push(resolve(yarnBase, 'node_modules'), resolve(yarnBase, '../link/'));
     }
     // Get npm global prefix and infer the module paths from there
     const globalInstall = execaOutput('npm', ['root', '-g']);
@@ -219,5 +219,5 @@ function getGlobalNpmPaths(filterPaths = true) {
     if (process.argv[1]) {
         paths.push(...filterValidNpmPath(join(dirname(process.argv[1]), '../..'), !filterPaths));
     }
-    return uniq(paths.filter(Boolean).reverse());
+    return uniq(paths.filter(Boolean).toReversed());
 }

package/dist/package-manager.d.ts

@@ -1,12 +1,13 @@
 import type { MemFsEditorFile } from 'mem-fs-editor';
-import { type InputOutputAdapter } from '@yeoman/types';
-import { type Store } from 'mem-fs';
+import type { InputOutputAdapter } from '@yeoman/types';
+import type { Store } from 'mem-fs';
+export type InstallTask = (nodePackageManager: string | undefined, defaultTask: () => Promise<boolean>) => void | Promise<void>;
 export type PackageManagerInstallTaskOptions = {
     memFs: Store<MemFsEditorFile>;
     packageJsonLocation: string;
     adapter: InputOutputAdapter;
     nodePackageManager?: string;
-    customInstallTask?: boolean | ((nodePackageManager: string | undefined, defaultTask: () => Promise<boolean>) => void | Promise<void>);
+    customInstallTask?: boolean | InstallTask;
     skipInstall?: boolean;
 };
 /**

package/dist/store.d.ts

@@ -7,10 +7,10 @@ import type { BaseEnvironment, BaseGeneratorMeta, GeneratorMeta, GetGeneratorCon
  * @private
  */
 export default class Store {
-    private readonly environment;
     private readonly _meta;
     private readonly _packagesPaths;
     private readonly _packagesNS;
+    private readonly environment;
     constructor(environment: BaseEnvironment);
     /**
      * Store a module under the namespace key

package/dist/store.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { pathToFileURL } from 'node:url';
 import { extname, join } from 'node:path';
 import { createRequire } from 'node:module';
@@ -13,12 +21,12 @@ const require = createRequire(import.meta.url);
  * @private
  */
 export default class Store {
-    environment;
     _meta = {};
     // Store packages paths by ns
     _packagesPaths = {};
     // Store packages ns
     _packagesNS = [];
+    environment;
     constructor(environment) {
         this.environment = environment;
     }
@@ -51,28 +59,60 @@ export default class Store {
             if (!meta.resolved) {
                 throw new Error(`Generator Stub or resolved path is required for ${meta.namespace}`);
             }
-            importModule = async () => import(pathToFileURL(meta.resolved).href);
+            importModule = () => {
+                try {
+                    return require(meta.resolved);
+                }
+                catch {
+                    return import(__rewriteRelativeImportExtension(pathToFileURL(meta.resolved).href));
+                }
+            };
         }
         let importPromise;
-        const importGenerator = async () => {
+        // eslint-disable-next-line prefer-const
+        let generatorMeta;
+        const importGenerator = () => {
+            const handleImport = () => {
+                if (importModule && !Generator) {
+                    const maybeModule = importModule();
+                    if (maybeModule.then) {
+                        importPromise = maybeModule;
+                        return maybeModule.then((mod) => {
+                            Generator = mod;
+                            importPromise = undefined;
+                        });
+                    }
+                    else {
+                        Generator = maybeModule;
+                    }
+                }
+            };
+            const handleModule = () => {
+                const factory = this.getFactory(Generator);
+                if (typeof factory === 'function') {
+                    importPromise = factory(this.environment);
+                    return Promise.resolve(importPromise).then((mod) => {
+                        const generator = this._getGenerator(mod, meta, generatorMeta);
+                        Generator = generator;
+                        importPromise = undefined;
+                        return generator;
+                    });
+                }
+                return this._getGenerator(Generator, meta, generatorMeta);
+            };
             if (importPromise) {
-                Generator = await importPromise;
-            }
-            if (importModule && !Generator) {
-                importPromise = importModule();
-                Generator = await importPromise;
+                return importPromise.then(() => Promise.resolve(handleImport()).then(() => handleModule()));
             }
-            const factory = this.getFactory(Generator);
-            if (typeof factory === 'function') {
-                importPromise = factory(this.environment);
-                Generator = await importPromise;
+            const maybeImportPromise = handleImport();
+            if (maybeImportPromise?.then) {
+                return maybeImportPromise.then(() => handleModule());
             }
-            return this._getGenerator(Generator, meta);
+            return handleModule();
         };
         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 = {
+        generatorMeta = {
             ...meta,
             importGenerator,
             importModule,
@@ -132,7 +172,7 @@ export default class Store {
                 debug('Overriding a package with namespace %s and path %s, with path %s', packageNS, this._packagesPaths[packageNS][0], packagePath);
                 // Remove old packagePath
                 const index = packagePaths.indexOf(packagePath);
-                if (index > -1) {
+                if (index !== -1) {
                     packagePaths.splice(index, 1);
                 }
                 packagePaths.splice(0, 0, packagePath);
@@ -169,12 +209,13 @@ export default class Store {
         // 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) {
+    _getGenerator(module, meta, generatorMeta) {
         const Generator = module.default?.default ?? module.default ?? module;
         if (typeof Generator !== 'function') {
             throw new TypeError("The generator doesn't provide a constructor.");
         }
         Object.assign(Generator, meta);
+        Generator._meta = generatorMeta;
         return Generator;
     }
 }

package/dist/util/command.d.ts

@@ -1,6 +1,7 @@
 import { Command, Option } from 'commander';
-import type BaseEnvironment from '../environment-base.js';
+import type BaseEnvironment from '../environment-base.ts';
 export default class YeomanCommand extends Command {
+    #private;
     env?: BaseEnvironment;
     createCommand(name?: string): YeomanCommand;
     /**
@@ -29,6 +30,6 @@ export default class YeomanCommand extends Command {
      * @return {YeomanCommand} this;
      */
     addGeneratorOptions(options: Record<string, any>): this;
-    _addGeneratorOption(optionName: string, optionDefinition: any, additionalDescription?: string): any;
+    _addGeneratorOption(optionName: string, optionDefinition: any, additionalDescription?: string): Option | this | undefined;
 }
 export declare const addEnvironmentOptions: (command?: YeomanCommand) => YeomanCommand;

package/dist/util/command.js

@@ -65,13 +65,16 @@ export default class YeomanCommand extends Command {
         }
         return this;
     }
+    #findOption(arg) {
+        return this.options.find(option => option.short === arg || option.long === arg);
+    }
     _addGeneratorOption(optionName, optionDefinition, additionalDescription = '') {
         if (optionName === 'help') {
             return;
         }
         const longOption = `--${optionName}`;
-        const existingOption = this._findOption(longOption);
-        if (this._findOption(longOption)) {
+        const existingOption = this.#findOption(longOption);
+        if (this.#findOption(longOption)) {
             return existingOption;
         }
         let cmdString = '';

package/dist/util/namespace.js

@@ -40,7 +40,7 @@ export const asNamespace = (filepath, { lookups = defaultLookups }) => {
     const nsLookups = [...lookups, '..']
         .map(found => slash(found))
         .sort((a, b) => a.split('/').length - b.split('/').length)
-        .reverse();
+        .toReversed();
     // If `ns` contains a lookup dir in its path, remove it.
     for (const lookup of nsLookups) {
         // Only match full directory (begin with leading slash or start of input, end with trailing slash)

package/dist/util/resolve.d.ts

@@ -3,4 +3,4 @@
  * @param  specifier - Filepath or module name
  * @return           - The resolved path leading to the module
  */
-export declare function resolveModulePath(specifier: string, resolvedOrigin?: string): Promise<string | undefined>;
+export declare function resolveModulePath(specifier: string, resolvedOrigin?: string): string | undefined;

package/dist/util/resolve.js

@@ -1,14 +1,14 @@
 import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
-import { realpath, stat } from 'node:fs/promises';
+import { realpathSync, statSync } from 'node:fs';
 import untildify from 'untildify';
-import { locatePath } from 'locate-path';
-import { defaultExtensions } from '../generator-lookup.js';
+import { locatePathSync } from 'locate-path';
+import { defaultExtensions } from "../generator-lookup.js";
 /**
  * Resolve a module path
  * @param  specifier - Filepath or module name
  * @return           - The resolved path leading to the module
  */
-export async function resolveModulePath(specifier, resolvedOrigin) {
+export function resolveModulePath(specifier, resolvedOrigin) {
     let maybeResolved = specifier;
     if (maybeResolved.startsWith('.')) {
         if (resolvedOrigin) {
@@ -24,15 +24,15 @@ export async function resolveModulePath(specifier, resolvedOrigin) {
         maybeResolved += sep;
     }
     try {
-        let specStat = await stat(maybeResolved);
+        let specStat = statSync(maybeResolved);
         if (specStat.isSymbolicLink()) {
-            specStat = await stat(await realpath(maybeResolved));
+            specStat = statSync(realpathSync(maybeResolved));
         }
         if (specStat.isFile()) {
             return maybeResolved;
         }
         if (specStat.isDirectory()) {
-            return await locatePath(defaultExtensions.map(extension => `index${extension}`).map(file => join(maybeResolved, file)));
+            return locatePathSync(defaultExtensions.map(extension => `index${extension}`).map(file => join(maybeResolved, file)));
         }
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.0-beta.1",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",
@@ -58,18 +58,18 @@
   },
   "dependencies": {
     "@yeoman/adapter": "^2.1.1",
-    "@yeoman/conflicter": "^2.4.0",
+    "@yeoman/conflicter": "^3.0.0",
     "@yeoman/namespace": "^1.0.1",
     "@yeoman/transform": "^2.1.0",
-    "@yeoman/types": "^1.6.0",
+    "@yeoman/types": "^1.7.1",
     "arrify": "^3.0.0",
-    "chalk": "^5.4.1",
-    "commander": "^13.1.0",
-    "debug": "^4.4.0",
-    "execa": "^9.5.3",
-    "fly-import": "^0.4.1",
+    "chalk": "^5.5.0",
+    "commander": "^14.0.0",
+    "debug": "^4.4.1",
+    "execa": "^9.6.0",
+    "fly-import": "^1.0.0",
     "globby": "^14.1.0",
-    "grouped-queue": "^2.0.0",
+    "grouped-queue": "^2.1.0",
     "locate-path": "^7.2.0",
     "lodash-es": "^4.17.21",
     "mem-fs": "^4.1.2",
@@ -82,22 +82,22 @@
   "devDependencies": {
     "@types/debug": "^4.1.12",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^18.19.100",
+    "@types/node": "^20.19.11",
     "@types/semver": "^7.7.0",
-    "@yeoman/eslint": "0.2.0",
+    "@yeoman/eslint": "1.0.0",
     "c8": "^10.1.3",
-    "cpy-cli": "^5.0.0",
-    "eslint": "9.12.0",
-    "esmocha": "^3.0.0",
-    "fs-extra": "^11.3.0",
+    "cpy-cli": "^6.0.0",
+    "eslint": "9.33.0",
+    "esmocha": "^4.0.0",
+    "fs-extra": "^11.3.1",
     "jsdoc": "^4.0.4",
-    "prettier": "3.5.3",
-    "prettier-plugin-packagejson": "^2.5.12",
+    "prettier": "3.6.2",
+    "prettier-plugin-packagejson": "^2.5.19",
     "rimraf": "^6.0.1",
-    "sinon": "^20.0.0",
+    "sinon": "^21.0.0",
     "sinon-test": "^3.1.6",
     "strip-ansi": "^7.1.0",
-    "typescript": "5.8.3",
+    "typescript": "5.9.2",
     "yeoman-assert": "^3.1.1",
     "yeoman-environment": "file:./",
     "yeoman-generator-2": "npm:yeoman-generator@^2.0.5",
@@ -105,11 +105,12 @@
     "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": "^10.1.0"
+    "yeoman-generator-8": "npm:yeoman-generator@^8.0.0-beta.0",
+    "yeoman-test": "^10.1.1"
   },
   "peerDependencies": {
-    "@yeoman/types": "^1.1.1",
-    "mem-fs": "^4.0.0"
+    "@yeoman/types": "^1.7.1",
+    "mem-fs": "^4.1.2"
   },
   "engines": {
     "node": "^20.17.0 || >=22.9.0"
@@ -131,7 +132,7 @@
       "shelljs": "^0.8.5",
       "sort-keys": "^4.2.0",
       "text-table": "^0.2.0",
-      "yeoman-environment": "^3.19.3"
+      "yeoman-environment": "file:./"
     },
     "yeoman-generator-4": {
       "chalk": "^4.1.0",
@@ -149,7 +150,7 @@
       "shelljs": "^0.8.5",
       "sort-keys": "^4.2.0",
       "text-table": "^0.2.0",
-      "yeoman-environment": "^3.19.3"
+      "yeoman-environment": "file:./"
     },
     "yeoman-generator-5": {
       "chalk": "^4.1.0",
@@ -167,10 +168,16 @@
       "shelljs": "^0.8.5",
       "sort-keys": "^4.2.0",
       "text-table": "^0.2.0",
-      "yeoman-environment": "*"
+      "yeoman-environment": "file:./"
     },
     "yeoman-generator-6": {
-      "yeoman-environment": "*"
+      "yeoman-environment": "file:./"
+    },
+    "yeoman-generator-7": {
+      "yeoman-environment": "file:./"
+    },
+    "yeoman-generator-8": {
+      "yeoman-environment": "file:./"
     }
   }
 }