yeoman-environment 8.1.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,12 @@ 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) {
         if (adapterCompat) {
@@ -108,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
@@ -262,8 +262,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/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/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';
+import { escapeRegExp } from "./util.js";
+/** 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();
@@ -47,15 +56,21 @@ export const asNamespace = (filepath, { lookups = defaultLookups }) => {
         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 `/`
-        .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/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.1.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",