yeoman-environment 8.1.0 → 8.2.0

package/dist/environment-full.js

@@ -8,6 +8,7 @@ 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";
+import { nestedGeneratorsFolder } from "./util/namespace.js";
 class FullEnvironment extends EnvironmentBase {
     constructor(options = {}, adapterCompat) {
         if (adapterCompat) {
@@ -262,8 +263,12 @@ class FullEnvironment extends EnvironmentBase {
             const nsOptions = { packagePatterns: [ns.generatorHint] };
             if (ns.generator) {
                 // Build filePatterns to look specifically for the namespace.
-                const genPath = ns.generator.split(':').join('/');
-                let filePatterns = [`${genPath}/index.?s`, `${genPath}.?s`];
+                const generatorPaths = [ns.generator.split(':').join('/')];
+                if (options.nestedGenerators ?? this.store.lookupOptions.nestedGenerators) {
+                    // `app:sub` is `app/generators/sub` too.
+                    generatorPaths.push(ns.generator.split(':').join(`/${nestedGeneratorsFolder}/`));
+                }
+                let filePatterns = generatorPaths.flatMap(genPath => [`${genPath}/index.?s`, `${genPath}.?s`]);
                 const lookups = options.lookups ?? this.store.lookups;
                 filePatterns = lookups.flatMap(prefix => filePatterns.map(pattern => join(prefix, pattern)));
                 nsOptions.filePatterns = filePatterns;

package/dist/generator-lookup.d.ts

@@ -2,6 +2,11 @@ import type { LookupOptions as LookupOptionsApi } from '@yeoman/types';
 import { type ModuleLookupOptions } from './module-lookup.ts';
 export type LookupOptions = LookupOptionsApi & ModuleLookupOptions & {
     lookups?: string[];
+    /**
+     * Look up the generators nested in the `generators` folder of a generator too:
+     * `generators/server/generators/cache` is registered as `server:cache`.
+     */
+    nestedGenerators?: boolean;
 };
 type LookupMeta = {
     filePath: string;
@@ -49,13 +54,13 @@ export declare function lookupGeneratorsSync(options?: LookupOptions, register?:
  * @param {Boolean} [options.singleResult=true] - Set false to return multiple values.
  * @return {String} generator
  */
-export declare function lookupGenerator(namespace: string, options?: ModuleLookupOptions & {
+export declare function lookupGenerator(namespace: string, options?: ModuleLookupOptions & Pick<LookupOptions, 'nestedGenerators'> & {
     packagePath?: boolean;
     generatorPath?: boolean;
 } & {
     singleResult?: true;
 }): string;
-export declare function lookupGenerator(namespace: string, options?: ModuleLookupOptions & {
+export declare function lookupGenerator(namespace: string, options?: ModuleLookupOptions & Pick<LookupOptions, 'nestedGenerators'> & {
     packagePath?: boolean;
     generatorPath?: boolean;
 } & {

package/dist/generator-lookup.js

@@ -2,7 +2,7 @@ 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 { defaultLookups } from "./util/namespace.js";
+import { defaultLookups, withNestedLookups } from "./util/namespace.js";
 import Store from "./store.js";
 export const defaultExtensions = ['.ts', '.cts', '.mts', '.js', '.cjs', '.mjs'];
 /**
@@ -30,10 +30,10 @@ export const defaultExtensions = ['.ts', '.cts', '.mts', '.js', '.cjs', '.mjs'];
  * @return {Object[]} List of generators
  */
 export function lookupGeneratorsSync(options = {}, register) {
-    const { lookups = defaultLookups } = options;
+    const { lookups = defaultLookups, nestedGenerators } = options;
     options = {
         // Js generators should be after, last will override registered one.
-        filePatterns: lookups.flatMap(prefix => defaultExtensions.map(extension => `${prefix}/*/index${extension}`)),
+        filePatterns: withNestedLookups(lookups, nestedGenerators).flatMap(prefix => defaultExtensions.map(extension => `${prefix}/*/index${extension}`)),
         filterPaths: false,
         packagePatterns: ['generator-*'],
         reverse: !options.singleResult,
@@ -64,7 +64,7 @@ export function lookupGenerator(namespace, options) {
     }
     // The generators are looked up by a store of their own, which keeps the ones asked for.
     const generators = new Store().lookupSync({
-        filePatterns: defaultLookups.map(prefix => join(prefix, '*/index.{js,ts}')),
+        filePatterns: withNestedLookups(defaultLookups, lookupOptions.nestedGenerators).map(prefix => join(prefix, '*/index.{js,ts}')),
         reverse: false,
         ...lookupOptions,
         lookups: defaultLookups,

package/dist/store.d.ts

@@ -22,7 +22,7 @@ export type StoreLookupOptions = LookupOptions & StoreEnvironmentOptions & {
  * Lookup options shared by every lookup of a store, the options passed to a lookup take precedence.
  * What to look up (paths, package patterns and `singleResult`) is given by each lookup.
  */
-export type StoreSharedLookupOptions = Pick<StoreLookupOptions, 'lookups' | 'localOnly' | 'filterPaths' | 'customizeNamespace' | 'filter' | 'usePackageName'>;
+export type StoreSharedLookupOptions = Pick<StoreLookupOptions, 'lookups' | 'localOnly' | 'filterPaths' | 'customizeNamespace' | 'filter' | 'usePackageName' | 'nestedGenerators'>;
 /** A generator found by a lookup, `registered` tells if it was added to the store. */
 export type StoreLookupGeneratorMeta = FoundGenerator & ((StoreGeneratorMeta & {
     registered: true;

package/dist/store.js

@@ -10,7 +10,7 @@ import { pathToFileURL } from 'node:url';
 import { basename, extname, join, relative } from 'node:path';
 import { createRequire } from 'node:module';
 import { readFileSync, realpathSync } from 'node:fs';
-import { toNamespace } from '@yeoman/namespace';
+import { namespaceFromPackageName, toNamespace } from '@yeoman/namespace';
 import createDebug from 'debug';
 import { lookupGeneratorsSync } from "./generator-lookup.js";
 import { asNamespace, defaultLookups } from "./util/namespace.js";
@@ -20,6 +20,15 @@ const require = createRequire(import.meta.url);
 const operationsKey = Symbol('operations');
 const setOperations = (meta, operations) => Object.defineProperty(meta, operationsKey, { value: operations });
 const getOperations = (meta) => meta[operationsKey];
+/** The namespace of a generator package, like `@scope/foo` for `@scope/generator-foo`, undefined for another name. */
+const namespaceOfPackage = (packageName) => {
+    try {
+        return namespaceFromPackageName(packageName).namespace;
+    }
+    catch {
+        return undefined;
+    }
+};
 /**
  * The Generator store
  * This is used to store generator (npm packages) reference and instantiate them when
@@ -74,7 +83,7 @@ export default class Store {
      * @param lookups - The lookups of the store if omitted
      */
     namespace(filepath, lookups = this.lookups) {
-        return asNamespace(filepath, { lookups });
+        return asNamespace(filepath, { lookups, nestedGenerators: this.lookupOptions.nestedGenerators });
     }
     /**
      * A copy of the store with the same generators, packages and lookup options, whose metas default to the given
@@ -264,25 +273,33 @@ export default class Store {
         const { registerToScope, customizeNamespace = (ns) => ns, usePackageName, filter, env, lookups = this.lookups, ...remainingOptions } = { ...this.lookupOptions, ...options };
         const lookupOptions = { ...remainingOptions, lookups };
         const generators = [];
+        const { nestedGenerators } = lookupOptions;
         lookupGeneratorsSync(lookupOptions, ({ packagePath, filePath, lookups }) => {
-            const packageName = usePackageName ? this.getPackageJson(packagePath)?.name : undefined;
-            let namespacePath;
-            if (packageName) {
-                namespacePath = join(packageName, relative(packagePath, filePath));
-            }
-            else {
-                let repositoryPath = join(packagePath, '..');
-                if (basename(repositoryPath).startsWith('@')) {
-                    // Scoped package
-                    repositoryPath = join(repositoryPath, '..');
-                }
-                namespacePath = relative(repositoryPath, filePath);
-            }
-            let namespace = customizeNamespace(asNamespace(namespacePath, { lookups }));
+            let namespace;
             try {
+                const packageName = usePackageName ? this.getPackageJson(packagePath)?.name : undefined;
+                const packageNamespace = packageName ? namespaceOfPackage(packageName) : undefined;
+                let foundNamespace;
+                if (packageNamespace) {
+                    // The namespace of the package, then the generator from its path in the package.
+                    const generatorPath = join('generator-package', relative(packagePath, filePath));
+                    foundNamespace = `${packageNamespace}${asNamespace(generatorPath, { lookups, nestedGenerators }).slice('package'.length)}`;
+                }
+                else if (packageName) {
+                    foundNamespace = asNamespace(join(packageName, relative(packagePath, filePath)), { lookups, nestedGenerators });
+                }
+                else {
+                    let repositoryPath = join(packagePath, '..');
+                    if (basename(repositoryPath).startsWith('@')) {
+                        // Scoped package
+                        repositoryPath = join(repositoryPath, '..');
+                    }
+                    foundNamespace = asNamespace(relative(repositoryPath, filePath), { lookups, nestedGenerators });
+                }
+                namespace = customizeNamespace(foundNamespace);
                 const resolved = realpathSync(filePath);
                 if (!namespace) {
-                    namespace = customizeNamespace(asNamespace(resolved, { lookups }));
+                    namespace = customizeNamespace(asNamespace(resolved, { lookups, nestedGenerators }));
                 }
                 namespace = namespace;
                 if (registerToScope && !namespace.startsWith('@')) {

package/dist/util/namespace.d.ts

@@ -1,6 +1,15 @@
 type AsNamespaceOptions = {
     lookups?: string[];
+    /** Generators nested in the `generators` folder of a generator: `app/generators/sub` is `app:sub`. */
+    nestedGenerators?: boolean;
 };
+/** The folder holding the generators nested in a generator. */
+export declare const nestedGeneratorsFolder = "generators";
+/**
+ * The lookups of the generators, with the lookups of the generators nested in them if `nestedGenerators`:
+ * `generators` and `generators/*\/generators`.
+ */
+export declare const withNestedLookups: (lookups: string[], nestedGenerators?: boolean) => string[];
 export declare const defaultLookups: string[];
 /**
  * Given a String `filepath`, tries to figure out the relative namespace.
@@ -21,6 +30,7 @@ export declare const defaultLookups: string[];
  *
  * @param filepath
  * @param lookups paths
+ * @throws if the path is in a scoped package that is not a `generator-` one
  */
-export declare const asNamespace: (filepath: string, { lookups }: AsNamespaceOptions) => string;
+export declare const asNamespace: (filepath: string, { lookups, nestedGenerators }: AsNamespaceOptions) => string;
 export {};

package/dist/util/namespace.js

@@ -1,6 +1,13 @@
-import { parse } from 'node:path';
+import { parse, posix } from 'node:path';
 import slash from 'slash';
 import { escapeRegExp, findLast } from 'lodash-es';
+/** The folder holding the generators nested in a generator. */
+export const nestedGeneratorsFolder = 'generators';
+/**
+ * The lookups of the generators, with the lookups of the generators nested in them if `nestedGenerators`:
+ * `generators` and `generators/*\/generators`.
+ */
+export const withNestedLookups = (lookups, nestedGenerators) => nestedGenerators ? lookups.flatMap(lookup => [lookup, posix.join(lookup, '*', nestedGeneratorsFolder)]) : lookups;
 export const defaultLookups = ['.', 'generators', 'lib/generators', 'dist/generators'];
 /**
  * Given a String `filepath`, tries to figure out the relative namespace.
@@ -21,8 +28,9 @@ export const defaultLookups = ['.', 'generators', 'lib/generators', 'dist/genera
  *
  * @param filepath
  * @param lookups paths
+ * @throws if the path is in a scoped package that is not a `generator-` one
  */
-export const asNamespace = (filepath, { lookups = defaultLookups }) => {
+export const asNamespace = (filepath, { lookups = defaultLookups, nestedGenerators }) => {
     if (!filepath) {
         throw new Error('Missing file path');
     }
@@ -37,7 +45,8 @@ export const asNamespace = (filepath, { lookups = defaultLookups }) => {
     const parsed = parse(ns);
     ns = parsed.dir ? `${parsed.dir}/${parsed.name}` : parsed.name;
     // Sort lookups by length so biggest are removed first
-    const nsLookups = [...lookups, '..']
+    // The folder of the nested generators is removed like a lookup.
+    const nsLookups = [...lookups, ...(nestedGenerators ? [nestedGeneratorsFolder] : []), '..']
         .map(found => slash(found))
         .toSorted((a, b) => a.split('/').length - b.split('/').length)
         .toReversed();
@@ -51,11 +60,17 @@ export const asNamespace = (filepath, { lookups = defaultLookups }) => {
     // Cleanup `ns` from unwanted parts and then normalize slashes to `:`
     ns = ns
         .replaceAll('//', '') // Remove double `/`
-        .replace(/(.*generator-)/, '') // Remove before `generator-`
+        // Remove the path before the package, the last folder starting with `generator-`, and its `generator-` prefix:
+        // a `generator-` inside the name of the package or of a generator is kept.
+        .replace(/^(?:.*\/)?generator-/, '')
         .replace(/\/(index|main)$/, '') // Remove `/index` or `/main`
         .replace(/^\//, '') // Remove leading `/`
         .replaceAll(/\/+/g, ':'); // Replace slashes by `:`
     if (scope) {
+        // The path up to the scope is left when the package is not a `generator-` one.
+        if (new RegExp(`(?:^|:)${escapeRegExp(scope)}:`).test(ns)) {
+            throw new Error(`The scoped package of ${filepath} is not a generator- package, it has no namespace.`);
+        }
         ns = `${scope}/${ns}`;
     }
     return ns;

package/package.json

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