fix: improve types

Author: mshima

package-lock.json

@@ -61,7 +61,7 @@
     "@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.5.0",
     "commander": "^14.0.0",
@@ -109,8 +109,8 @@
     "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"

package.json

@@ -9,7 +9,7 @@ import type {
   BaseEnvironment,
   BaseEnvironmentOptions,
   BaseGenerator,
-  BaseGeneratorConstructor,
+  BaseGeneratorConstructorMeta,
   BaseGeneratorMeta,
   ComposeOptions,
   GeneratorMeta,
@@ -293,11 +293,12 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
    * @param   namespaceOrPath
    * @return the generator registered under the namespace
    */
-  async get<C extends BaseGeneratorConstructor = BaseGeneratorConstructor>(
+  get<G extends BaseGenerator = BaseGenerator>(
     namespaceOrPath: string | YeomanNamespace,
-  ): Promise<C | undefined> {
-    const meta = await this.findMeta(namespaceOrPath);
-    return meta?.importGenerator() as Promise<C>;
+  ):
+    | Promise<(GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined>
+    | ((GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined) {
+    return this.findMeta(namespaceOrPath)?.importGenerator();
   }
 
   /**
@@ -312,22 +313,21 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
    * @return The instantiated generator
    */
   async create<G extends BaseGenerator = BaseGenerator>(
-    namespaceOrPath: string | GetGeneratorConstructor<G>,
+    namespaceOrPath: string | (GetGeneratorConstructor<G> & Partial<BaseGeneratorConstructorMeta>),
     instantiateOptions?: InstantiateOptions<G>,
   ): Promise<G>;
   create<G extends BaseGenerator = BaseGenerator>(
-    namespaceOrPath: string | GetGeneratorConstructor<G>,
+    namespaceOrPath: string | (GetGeneratorConstructor<G> & Partial<BaseGeneratorConstructorMeta>),
     ...arguments_: any[]
   ): Promise<G> | G {
-    let constructor;
     const namespace = typeof namespaceOrPath === 'string' ? toNamespace(namespaceOrPath) : undefined;
 
-    const checkGenerator = (Generator: any) => {
+    const checkGenerator = <const T extends Partial<BaseGeneratorConstructorMeta>>(Generator?: T): T => {
       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.
         }
@@ -350,32 +350,23 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
       return Generator;
     };
 
-    if (typeof namespaceOrPath !== 'string') {
-      return this.instantiate(checkGenerator(namespaceOrPath), ...arguments_);
-    }
-
     if (typeof namespaceOrPath === 'string') {
       const meta = this.findMeta(namespaceOrPath);
-      constructor = meta?.importGenerator();
+      const constructor = meta?.importGenerator();
       if (namespace && !constructor) {
         // Await this.lookupLocalNamespaces(namespace);
         // constructor = await this.get(namespace);
       }
 
-      if (constructor) {
-        if ((constructor as any).then) {
-          return constructor.then(g => {
-            (g as any)._meta = meta;
-            return this.instantiate(checkGenerator(g), ...arguments_);
-          });
-        }
-        (constructor as any)._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_);
   }
 
   /**
@@ -389,9 +380,12 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     generator: GetGeneratorConstructor<G>,
     instantiateOptions?: InstantiateOptions<G>,
   ): Promise<G>;
-  instantiate<G extends BaseGenerator = BaseGenerator>(constructor: GetGeneratorConstructor<G>, ...arguments_: any[]): Promise<G> | G {
+  instantiate<G extends BaseGenerator = BaseGenerator>(
+    constructor: GetGeneratorConstructor<G> & Partial<BaseGeneratorConstructorMeta>,
+    ...arguments_: any[]
+  ): Promise<G> | G {
     const composeOptions = arguments_.length > 0 ? (getInstantiateOptions(...arguments_) as InstantiateOptions<G>) : {};
-    const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED, _meta } = constructor as any;
+    const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED, _meta } = constructor;
     const environmentOptions = { env: this, resolved, namespace };
     const generator = new constructor(composeOptions.generatorArgs ?? [], {
       ...this.sharedOptions,
@@ -836,7 +830,8 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     return new Promise<void>((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();

src/environment-base.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { join, resolve } from 'node:path';
-import type { BaseGeneratorConstructor, InputOutputAdapter } from '@yeoman/types';
+import type { BaseGeneratorConstructor, BaseGeneratorOptions, GeneratorEnvironmentOptions, InputOutputAdapter } from '@yeoman/types';
 import { type YeomanNamespace, requireNamespace, toNamespace } from '@yeoman/namespace';
 import { flyImport } from 'fly-import';
 import { defaults, pick, uniq } from 'lodash-es';
@@ -337,13 +337,12 @@ 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_?: string[], options?: any) {
+  async run(
+    arguments_?: string | string[],
+    options: EnvironmentOptions & BaseGeneratorOptions & Partial<GeneratorEnvironmentOptions> = {},
+  ) {
     arguments_ = Array.isArray(arguments_) ? arguments_ : splitArgumentsFromString(arguments_ as unknown as string);
-    options = { ...options };
 
     let name = arguments_.shift();
     if (!name) {
@@ -366,10 +365,7 @@ class FullEnvironment extends EnvironmentBase {
 
     const generator = await this.create(name, {
       generatorArgs: arguments_,
-      generatorOptions: {
-        ...options,
-        initialGenerator: true,
-      },
+      generatorOptions: options,
     });
 
     if (options.help) {

src/environment-full.ts

@@ -2,7 +2,14 @@ import { pathToFileURL } from 'node:url';
 import { extname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { toNamespace } from '@yeoman/namespace';
-import type { BaseEnvironment, BaseGeneratorMeta, GeneratorMeta, GetGeneratorConstructor } from '@yeoman/types';
+import type {
+  BaseEnvironment,
+  BaseGenerator,
+  BaseGeneratorConstructorMeta,
+  BaseGeneratorMeta,
+  GeneratorMeta,
+  GetGeneratorConstructor,
+} from '@yeoman/types';
 import createDebug from 'debug';
 
 const debug = createDebug('yeoman:environment:store');
@@ -68,7 +75,12 @@ export default class Store {
     }
 
     let importPromise: Promise<unknown> | undefined;
-    const importGenerator = () => {
+    // eslint-disable-next-line prefer-const
+    let generatorMeta: (GeneratorMeta & M) | undefined;
+
+    const importGenerator: GeneratorMeta['importGenerator'] = <G extends BaseGenerator>():
+      | Promise<GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta>
+      | (GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) => {
       const handleImport = () => {
         if (importModule && !Generator) {
           const maybeModule = importModule();
@@ -84,18 +96,21 @@ export default class Store {
         }
       };
 
-      const handleModule = () => {
+      const handleModule = <G extends BaseGenerator>():
+        | Promise<GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta>
+        | (GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) => {
         const factory = this.getFactory(Generator);
         if (typeof factory === 'function') {
           importPromise = factory(this.environment);
           return Promise.resolve(importPromise).then((mod: any) => {
-            Generator = this._getGenerator(mod, meta);
+            const generator = this._getGenerator<G>(mod, meta, generatorMeta);
+            Generator = generator;
             importPromise = undefined;
-            return Generator;
+            return generator;
           });
         }
 
-        return this._getGenerator(Generator, meta);
+        return this._getGenerator<G>(Generator, meta, generatorMeta);
       };
 
       if (importPromise) {
@@ -109,12 +124,12 @@ export default class Store {
       return handleModule();
     };
 
-    const instantiate = async (arguments_: string[] = [], options: any = {}) =>
-      this.environment.instantiate(await importGenerator(), { generatorArgs: arguments_, generatorOptions: options });
-    const instantiateHelp = async () => instantiate([], { help: true });
+    const instantiate: GeneratorMeta['instantiate'] = async <G extends BaseGenerator>(arguments_: string[] = [], options: any = {}) =>
+      this.environment.instantiate<G>(await importGenerator<G>(), { generatorArgs: arguments_, generatorOptions: options });
+    const instantiateHelp: GeneratorMeta['instantiateHelp'] = async () => instantiate([], { help: true });
     const { packageNamespace } = toNamespace(meta.namespace) ?? {};
 
-    const generatorMeta = {
+    generatorMeta = {
       ...meta,
       importGenerator,
       importModule,
@@ -229,13 +244,18 @@ export default class Store {
     return module.createGenerator ?? module.default?.createGenerator ?? module.default?.default?.createGenerator;
   }
 
-  private _getGenerator(module: any, meta: BaseGeneratorMeta) {
+  private _getGenerator<G extends BaseGenerator>(
+    module: any,
+    meta: BaseGeneratorMeta,
+    generatorMeta: BaseGeneratorMeta | undefined,
+  ): GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta {
     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;
   }
 }