yeoman-environment 4.2.0 → 4.3.0

package/dist/environment-base.d.ts

@@ -17,7 +17,7 @@ export type EnvironmentLookupOptions = LookupOptions & {
     /** Add a scope to the namespace if there is no scope */
     registerToScope?: string;
     /** Customize the namespace to be registered */
-    customizeNamespace?: (ns?: string) => string;
+    customizeNamespace?: (ns?: string) => string | undefined;
 };
 export type EnvironmentOptions = BaseEnvironmentOptions & Omit<TerminalAdapterOptions, 'promptModule'> & {
     adapter?: InputOutputAdapter;
@@ -60,6 +60,11 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
         feature: any;
     }>;
     applyTransforms(transformStreams: FilePipelineTransform[], options?: ApplyTransformsOptions): Promise<void>;
+    /**
+     * @param   namespaceOrPath
+     * @return the generator meta registered under the namespace
+     */
+    findMeta(namespaceOrPath: string | YeomanNamespace): Promise<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

package/dist/environment-base.js

@@ -154,16 +154,10 @@ export default class EnvironmentBase extends EventEmitter {
         }, { name, disabled: !(options?.log ?? true) });
     }
     /**
-     * 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
-     * is found. Eg. if an `angular:common` namespace is registered, and we try to
-     * get `angular:common:all` then we get `angular:common` as a fallback (unless
-     * an `angular:common:all` generator is registered).
-     *
      * @param   namespaceOrPath
-     * @return the generator registered under the namespace
+     * @return the generator meta registered under the namespace
      */
-    async get(namespaceOrPath) {
+    async findMeta(namespaceOrPath) {
         // Stop the recursive search if nothing is left
         if (!namespaceOrPath) {
             return;
@@ -171,24 +165,35 @@ export default class EnvironmentBase extends EventEmitter {
         const parsed = toNamespace(namespaceOrPath);
         if (typeof namespaceOrPath !== 'string' || parsed) {
             const ns = parsed.namespace;
-            const maybeGenerator = (await this.store.get(ns)) ?? this.store.get(this.alias(ns));
-            return maybeGenerator;
+            return this.store.getMeta(ns) ?? this.store.getMeta(this.alias(ns));
         }
-        const maybeGenerator = (await this.store.get(namespaceOrPath)) ?? (await this.store.get(this.alias(namespaceOrPath)));
-        if (maybeGenerator) {
-            return maybeGenerator;
+        const maybeMeta = this.store.getMeta(namespaceOrPath) ?? this.store.getMeta(this.alias(namespaceOrPath));
+        if (maybeMeta) {
+            return maybeMeta;
         }
         try {
             const resolved = await resolveModulePath(namespaceOrPath);
             if (resolved) {
-                const namespace = this.namespace(resolved);
-                this.store.add({ resolved, namespace });
-                return (await this.store.get(namespace));
+                return this.store.add({ resolved, namespace: this.namespace(resolved) });
             }
         }
         catch { }
         return 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
+     * is found. Eg. if an `angular:common` namespace is registered, and we try to
+     * get `angular:common:all` then we get `angular:common` as a fallback (unless
+     * an `angular:common:all` generator is registered).
+     *
+     * @param   namespaceOrPath
+     * @return the generator registered under the namespace
+     */
+    async get(namespaceOrPath) {
+        const meta = await this.findMeta(namespaceOrPath);
+        return meta?.importGenerator();
+    }
     async create(namespaceOrPath, ...args) {
         let constructor;
         const namespace = typeof namespaceOrPath === 'string' ? toNamespace(namespaceOrPath) : undefined;
@@ -233,11 +238,15 @@ export default class EnvironmentBase extends EventEmitter {
             return this.instantiate(checkGenerator(namespaceOrPath), ...args);
         }
         if (typeof namespaceOrPath === 'string') {
-            constructor = await this.get(namespaceOrPath);
+            const meta = await this.findMeta(namespaceOrPath);
+            constructor = await meta?.importGenerator();
             if (namespace && !constructor) {
                 // Await this.lookupLocalNamespaces(namespace);
                 // constructor = await this.get(namespace);
             }
+            if (constructor) {
+                constructor._meta = meta;
+            }
         }
         else {
             constructor = namespaceOrPath;
@@ -246,13 +255,14 @@ export default class EnvironmentBase extends EventEmitter {
     }
     async instantiate(constructor, ...args) {
         const composeOptions = args.length > 0 ? getInstantiateOptions(...args) : {};
-        const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED } = constructor;
+        const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED, _meta } = constructor;
         const environmentOptions = { env: this, resolved, namespace };
         const generator = new constructor(composeOptions.generatorArgs ?? [], {
             ...this.sharedOptions,
             ...composeOptions.generatorOptions,
             ...environmentOptions,
         });
+        generator._meta = _meta;
         generator._environmentOptions = {
             ...this.options,
             ...this.sharedOptions,
@@ -434,6 +444,7 @@ export default class EnvironmentBase extends EventEmitter {
                 if (!namespace) {
                     namespace = customizeNamespace(asNamespace(resolved, { lookups }));
                 }
+                namespace = namespace;
                 if (registerToScope && !namespace.startsWith('@')) {
                     namespace = `@${registerToScope}/${namespace}`;
                 }
@@ -451,7 +462,7 @@ export default class EnvironmentBase extends EventEmitter {
             }
             generators.push({
                 resolved: filePath,
-                namespace,
+                namespace: namespace,
                 packagePath,
                 registered: false,
             });

package/dist/store.d.ts

@@ -23,13 +23,13 @@ export default class Store {
      * @param  {String} namespace
      * @return {Module}
      */
-    get(namespace: string): Promise<GetGeneratorConstructor>;
+    get(namespace: string): Promise<GetGeneratorConstructor | undefined>;
     /**
      * Get the module registered under the given namespace
      * @param  {String} namespace
      * @return {Module}
      */
-    getMeta(namespace: string): GeneratorMeta;
+    getMeta(namespace: string): GeneratorMeta | undefined;
     /**
      * Returns the list of registered namespace.
      * @return {Array} Namespaces array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",