yeoman-environment 8.2.0 → 8.3.0

package/dist/cli/utils.js

@@ -1,11 +1,14 @@
 import { requireNamespace } from '@yeoman/namespace';
-import { groupBy } from 'lodash-es';
 import createLogger from 'debug';
 import { createEnv as createEnvironment } from "../index.js";
 const debug = createLogger('yeoman:yoe');
 export const printGroupedGenerator = (generators) => {
-    const grouped = groupBy(generators, 'packagePath');
-    for (const [packagePath, group] of Object.entries(grouped)) {
+    const grouped = new Map();
+    for (const generator of generators) {
+        const packagePath = String(generator.packagePath);
+        grouped.set(packagePath, [...(grouped.get(packagePath) ?? []), generator]);
+    }
+    for (const [packagePath, group] of grouped) {
         const namespace = requireNamespace(group[0].namespace);
         console.log(`  ${namespace.packageNamespace} at ${packagePath}`);
         for (const generator of group) {

package/dist/environment-base.d.ts

@@ -47,6 +47,15 @@ export type EnvironmentOptions = ConflicterOptions & BaseEnvironmentOptions & Om
      */
     store?: Store;
 };
+/** The options to instantiate a generator with, and the namespace it was asked with. */
+type EnvironmentInstantiateOptions<G extends BaseGenerator = BaseGenerator> = InstantiateOptions<G> & {
+    /**
+     * The namespace the generator is created for, complete with its version, instance id, methods and flags
+     * (`namespace@semver@#id+method?`), passed to the generator as the `namespaceId` option. The `namespace` option
+     * stays the one of the generator, without them.
+     */
+    namespaceId?: string;
+};
 /**
  * Copy and remove null and undefined values
  * @param object
@@ -122,7 +131,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param instantiateOptions
      * @return The instantiated generator
      */
-    instantiate<G extends BaseGenerator = BaseGenerator>(generator: GetGeneratorConstructor<G>, instantiateOptions?: InstantiateOptions<G>): Promise<G>;
+    instantiate<G extends BaseGenerator = BaseGenerator>(generator: GetGeneratorConstructor<G>, instantiateOptions?: EnvironmentInstantiateOptions<G>): Promise<G>;
     /**
      * @protected
      * Compose with the generator.
@@ -314,3 +323,4 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      */
     getContextMap(key: string, factory?: () => Map<string, any>): Map<string, any>;
 }
+export {};

package/dist/environment-base.js

@@ -13,7 +13,6 @@ 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 {} from "./generator-lookup.js";
@@ -21,7 +20,7 @@ import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from "./constants.
 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 { defaults, pick, 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');
@@ -228,6 +227,17 @@ export default class EnvironmentBase extends EventEmitter {
             }
             return Generator;
         };
+        const instantiate = (Generator) => {
+            const checked = checkGenerator(Generator);
+            if (!namespace) {
+                return this.instantiate(checked, ...arguments_);
+            }
+            // Read after checkGenerator, which updates the namespace to the one of an aliased generator.
+            return this.instantiate(checked, {
+                ...getInstantiateOptions(...arguments_),
+                namespaceId: namespace.complete,
+            });
+        };
         if (typeof namespaceOrPath === 'string') {
             const meta = this.findMeta(namespaceOrPath);
             const constructor = meta?.importGenerator();
@@ -236,14 +246,12 @@ export default class EnvironmentBase extends EventEmitter {
                 // constructor = await this.get(namespace);
             }
             if (constructor && 'then' in constructor) {
-                return constructor.then(g => {
-                    return this.instantiate(checkGenerator(g), ...arguments_);
-                });
+                return constructor.then(g => instantiate(g));
             }
-            return this.instantiate(checkGenerator(constructor), ...arguments_);
+            return instantiate(constructor);
         }
         else {
-            return this.instantiate(checkGenerator(namespaceOrPath), ...arguments_);
+            return instantiate(namespaceOrPath);
         }
     }
     instantiate(constructor, ...arguments_) {
@@ -251,7 +259,8 @@ export default class EnvironmentBase extends EventEmitter {
         const { namespace = UNKNOWN_NAMESPACE, resolved = UNKNOWN_RESOLVED } = constructor;
         // The generator class keeps the meta of the store, which may be shared: the generator gets the one of this environment.
         const _meta = this.bindMeta(constructor._meta);
-        const environmentOptions = { env: this, resolved, namespace, _meta };
+        const { namespaceId } = composeOptions;
+        const environmentOptions = { env: this, resolved, namespace, _meta, ...(namespaceId && { namespaceId }) };
         const generator = new constructor(composeOptions.generatorArgs ?? [], {
             ...this.sharedOptions,
             ...composeOptions.generatorOptions,

package/dist/environment-full.d.ts

@@ -8,13 +8,13 @@ declare class FullEnvironment extends EnvironmentBase {
      *
      * @param {Object} options
      */
-    loadEnvironmentOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "skipInstall" | "nodePackageManager">;
+    loadEnvironmentOptions(options: EnvironmentOptions): Record<string, any>;
     /**
      * Load options passed to the Environment that should be forwarded to the Generator.
      *
      * @param {Object} options
      */
-    loadSharedOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "askAnswered" | "skipInstall" | "forceInstall" | "skipCache" | "skipLocalCache" | "skipParseOptions" | "localConfigOnly">;
+    loadSharedOptions(options: EnvironmentOptions): Record<string, any>;
     /**
      * @protected
      * Outputs the general help and usage. Optionally, if generators have been

package/dist/environment-full.js

@@ -2,12 +2,11 @@ import { createHash } from 'node:crypto';
 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 { 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";
+import { defaults, pick, splitArgsFromString as splitArgumentsFromString } from "./util/util.js";
 import { nestedGeneratorsFolder } from "./util/namespace.js";
 class FullEnvironment extends EnvironmentBase {
     constructor(options = {}, adapterCompat) {
@@ -109,7 +108,7 @@ class FullEnvironment extends EnvironmentBase {
      * @return {Array}
      */
     getGeneratorNames() {
-        return uniq(Object.keys(this.getGeneratorsMeta()).map(namespace => toNamespace(namespace)?.packageNamespace));
+        return [...new Set(Object.keys(this.getGeneratorsMeta()).map(namespace => toNamespace(namespace)?.packageNamespace))];
     }
     /**
      * Get last added path for a namespace

package/dist/module-lookup.js

@@ -3,7 +3,6 @@ import { delimiter, dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process from 'node:process';
 import arrify from 'arrify';
-import { compact, uniq } from 'lodash-es';
 import { globbySync } from 'globby';
 import slash from 'slash';
 import createdLogger from 'debug';
@@ -141,7 +140,7 @@ export function getNpmPaths(options = {}) {
     if (!options.localOnly) {
         paths = paths.concat(getGlobalNpmPaths(options.filterPaths));
     }
-    return uniq(paths);
+    return [...new Set(paths)];
 }
 /**
  * Get the local npm lookup directories
@@ -161,7 +160,7 @@ function getLocalNpmPaths() {
         }
         paths.push(lookup);
     });
-    return uniq(paths.toReversed());
+    return [...new Set(paths.toReversed())];
 }
 /**
  * Get the global npm lookup directories
@@ -197,7 +196,7 @@ function getGlobalNpmPaths(filterPaths = true) {
     // because of bugs in the parseable implementation of `ls` command and mostly
     // performance issues. So, we go with our best bet for now.
     if (process.env.NODE_PATH) {
-        paths = compact(process.env.NODE_PATH.split(delimiter)).concat(paths);
+        paths = process.env.NODE_PATH.split(delimiter).filter(Boolean).concat(paths);
     }
     // Global node_modules should be 4 or 2 directory up this one (most of the time)
     // Ex: /usr/another_global/node_modules/yeoman-denerator/node_modules/yeoman-environment/lib (1 level dependency)
@@ -228,5 +227,5 @@ function getGlobalNpmPaths(filterPaths = true) {
     if (process.argv[1]) {
         paths.push(...filterValidNpmPath(join(dirname(process.argv[1]), '../..'), !filterPaths));
     }
-    return uniq(paths.filter(Boolean).toReversed());
+    return [...new Set(paths.filter(Boolean).toReversed())];
 }

package/dist/util/namespace.js

@@ -1,6 +1,6 @@
 import { parse, posix } from 'node:path';
 import slash from 'slash';
-import { escapeRegExp, findLast } from 'lodash-es';
+import { escapeRegExp } from "./util.js";
 /** The folder holding the generators nested in a generator. */
 export const nestedGeneratorsFolder = 'generators';
 /**
@@ -56,7 +56,7 @@ export const asNamespace = (filepath, { lookups = defaultLookups, nestedGenerato
         ns = ns.replaceAll(new RegExp(`(?:/|^)${escapeRegExp(lookup)}(?=/)`, 'g'), '');
     }
     const folders = ns.split('/');
-    const scope = findLast(folders, folder => folder.startsWith('@'));
+    const scope = folders.findLast(folder => folder.startsWith('@'));
     // Cleanup `ns` from unwanted parts and then normalize slashes to `:`
     ns = ns
         .replaceAll('//', '') // Remove double `/`

package/dist/util/util.d.ts

@@ -4,3 +4,16 @@ export declare const execaOutput: (cmg: string, arguments_: string[]) => string
  * and then splits up the remaining arguments if they are not part of a quote.
  */
 export declare function splitArgsFromString(argumentsString: string | string[]): string[];
+/**
+ * The properties of an object present in it (own or inherited), like lodash `pick`.
+ */
+export declare const pick: (object: object | undefined, keys: readonly string[]) => Record<string, any>;
+/**
+ * Assign to the target the properties of the sources it has as undefined, the first source first, like lodash
+ * `defaults`.
+ */
+export declare const defaults: <T extends object>(target: T, ...sources: Array<object | undefined>) => T;
+/**
+ * Escape the characters with a meaning in a regular expression, like lodash `escapeRegExp`.
+ */
+export declare const escapeRegExp: (value: string) => string;

package/dist/util/util.js

@@ -34,3 +34,27 @@ export function splitArgsFromString(argumentsString) {
     }
     return result;
 }
+/**
+ * The properties of an object present in it (own or inherited), like lodash `pick`.
+ */
+export const pick = (object, keys) => Object.fromEntries(object ? keys.filter(key => key in object).map(key => [key, object[key]]) : []);
+/**
+ * Assign to the target the properties of the sources it has as undefined, the first source first, like lodash
+ * `defaults`.
+ */
+export const defaults = (target, ...sources) => {
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const key in source) {
+            if (target[key] === undefined) {
+                target[key] = source[key];
+            }
+        }
+    }
+    return target;
+};
+/**
+ * Escape the characters with a meaning in a regular expression, like lodash `escapeRegExp`.
+ */
+export const escapeRegExp = (value) => value.replaceAll(/[\\^$.*+?()[\]{}|]/g, String.raw `\$&`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",
@@ -72,7 +72,6 @@
     "globby": "^16.2.4",
     "grouped-queue": "^2.1.0",
     "locate-path": "^8.0.0",
-    "lodash-es": "^4.18.1",
     "mem-fs": "^6.0.0",
     "mem-fs-editor": "^12.0.9",
     "semver": "^7.8.5",
@@ -82,7 +81,6 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.13",
-    "@types/lodash-es": "^4.17.12",
     "@types/node": "^26.4.1",
     "@types/semver": "^7.8.0",
     "@yeoman/eslint": "1.1.0",