yeoman-environment 4.4.3 → 5.0.0-beta.1

package/bin/bin.cjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 (async function () {
+  // eslint-disable-next-line import-x/extensions
   await import('../dist/cli/index.js');
 })();

package/dist/cli/index.js

@@ -2,9 +2,9 @@ import { readFileSync } from 'node:fs';
 import process from 'node:process';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import YeomanCommand, { addEnvironmentOptions } from '../util/command.js';
-import { createEnv } from '../index.js';
-import { printGroupedGenerator, environmentAction } from './utils.js';
+import YeomanCommand, { addEnvironmentOptions } from "../util/command.js";
+import { createEnv as createEnvironment } from "../index.js";
+import { environmentAction, printGroupedGenerator } from "./utils.js";
 const program = new YeomanCommand();
 const packageJson = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json')).toString());
 program.version(packageJson.version).allowExcessArguments(false).enablePositionalOptions();
@@ -21,16 +21,16 @@ program
     .command('find')
     .description('Find installed generators')
     .action(async () => {
-    const env = createEnv();
-    printGroupedGenerator(await env.lookup());
+    const environment = createEnvironment();
+    printGroupedGenerator(await environment.lookup());
 });
 program
     .command('list')
     .description('List generators available to be used')
     .action(async () => {
-    const env = createEnv();
-    await env.lookup();
-    printGroupedGenerator(Object.values(env.getGeneratorsMeta()));
+    const environment = createEnvironment();
+    await environment.lookup();
+    printGroupedGenerator(Object.values(environment.getGeneratorsMeta()));
 });
 try {
     await program.parseAsync(process.argv);

package/dist/cli/utils.d.ts

@@ -1,5 +1,5 @@
 import type { BaseGeneratorMeta } from '@yeoman/types';
-import type YeomanCommand from '../util/command.js';
+import type YeomanCommand from '../util/command.ts';
 export declare const printGroupedGenerator: (generators: BaseGeneratorMeta[]) => void;
 /**
  * @param {string} generatorNamespace

package/dist/cli/utils.js

@@ -1,7 +1,7 @@
 import { requireNamespace } from '@yeoman/namespace';
 import { groupBy } from 'lodash-es';
 import createLogger from 'debug';
-import { createEnv } from '../index.js';
+import { createEnv as createEnvironment } from "../index.js";
 const debug = createLogger('yeoman:yoe');
 export const printGroupedGenerator = (generators) => {
     const grouped = groupBy(generators, 'packagePath');
@@ -27,8 +27,8 @@ export const environmentAction = async function (generatorNamespace, options, co
     if (!generatorNamespace) {
         return;
     }
-    const env = createEnv({ ...options, command: this });
-    this.env = env;
-    await env.lookupLocalPackages();
-    return env.execute(generatorNamespace, command.args.splice(1));
+    const environment = createEnvironment({ ...options, command: this });
+    this.env = environment;
+    await environment.lookupLocalPackages();
+    return environment.execute(generatorNamespace, command.args.splice(1));
 };

package/dist/commands.d.ts

@@ -1,5 +1,5 @@
-import { type BaseGeneratorConstructor } from '@yeoman/types';
-import YeomanCommand from './util/command.js';
+import type { BaseGeneratorConstructor } from '@yeoman/types';
+import YeomanCommand from './util/command.ts';
 export type CommandPreparation = {
     resolved?: string;
     command?: YeomanCommand;

package/dist/commands.js

@@ -1,5 +1,5 @@
-import YeomanCommand, { addEnvironmentOptions } from './util/command.js';
-import { createEnv } from './index.js';
+import YeomanCommand, { addEnvironmentOptions } from "./util/command.js";
+import { createEnv as createEnvironment } from "./index.js";
 /**
  * Prepare a commander instance for cli support.
  *
@@ -8,27 +8,26 @@ import { createEnv } from './index.js';
  * @return {Command} return command
  */
 export const prepareGeneratorCommand = async ({ command = addEnvironmentOptions(new YeomanCommand()), resolved, generator, namespace, }) => {
-    const env = createEnv();
+    const environment = createEnvironment();
     let meta;
     if (generator && namespace) {
-        meta = env.register(generator, { namespace, resolved });
+        meta = environment.register(generator, { namespace, resolved });
     }
     else if (resolved) {
-        meta = env.register(resolved, { namespace });
+        meta = environment.register(resolved, { namespace });
     }
     else {
         throw new Error(`A generator with namespace or a generator path is required`);
     }
-    command.env = env;
+    command.env = environment;
     command.registerGenerator(await meta.instantiateHelp());
     command.action(async function () {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let rootCommand = this;
         while (rootCommand.parent) {
             rootCommand = rootCommand.parent;
         }
         const generator = await meta.instantiate(this.args, this.opts());
-        await env.runGenerator(generator);
+        await environment.runGenerator(generator);
     });
     return command;
 };

package/dist/commit.d.ts

@@ -7,6 +7,6 @@ import { type MemFsEditorFile } from 'mem-fs-editor';
  */
 export declare const commitSharedFsTask: ({ adapter, conflicterOptions, sharedFs, }: {
     adapter: InputOutputAdapter;
-    conflicterOptions?: ConflicterOptions | undefined;
+    conflicterOptions?: ConflicterOptions;
     sharedFs: Store<MemFsEditorFile>;
 }) => Promise<void>;

package/dist/commit.js

@@ -1,6 +1,6 @@
 import { createConflicterTransform, createYoResolveTransform, forceYoFiles } from '@yeoman/conflicter';
 import createdLogger from 'debug';
-import { create as createMemFsEditor } from 'mem-fs-editor';
+import {} from 'mem-fs-editor';
 import { createCommitTransform } from 'mem-fs-editor/transform';
 import { isFilePending } from 'mem-fs-editor/state';
 const debug = createdLogger('yeoman:environment:commit');
@@ -9,6 +9,5 @@ const debug = createdLogger('yeoman:environment:commit');
  */
 export const commitSharedFsTask = async ({ adapter, conflicterOptions, sharedFs, }) => {
     debug('Running commitSharedFsTask');
-    const editor = createMemFsEditor(sharedFs);
     await sharedFs.pipeline({ filter: (file) => isFilePending(file) || file.path.endsWith('.yo-resolve') }, createYoResolveTransform(), forceYoFiles(), createConflicterTransform(adapter, conflicterOptions), createCommitTransform());
 };

package/dist/composed-store.d.ts

@@ -1,4 +1,5 @@
-import type { Logger, BaseGenerator } from '@yeoman/types';
+import type { BaseGenerator, Logger } from '@yeoman/types';
+import type { InstallTask } from './package-manager.ts';
 export declare class ComposedStore {
     private readonly log?;
     private readonly generators;
@@ -7,8 +8,8 @@ export declare class ComposedStore {
     constructor({ log }?: {
         log?: Logger;
     });
-    get customCommitTask(): any;
-    get customInstallTask(): any;
+    get customCommitTask(): (() => Promise<void> | void) | undefined;
+    get customInstallTask(): InstallTask | undefined;
     getGenerators(): Record<string, BaseGenerator>;
     addGenerator(generator: BaseGenerator): {
         uniqueBy: any;
@@ -22,9 +23,9 @@ export declare class ComposedStore {
         uniqueBy?: undefined;
     };
     getUniqueByPathMap(root: string): Map<string, BaseGenerator>;
-    findFeature(featureName: string): Array<{
+    findFeature<T = unknown>(featureName: string): Array<{
         generatorId: string;
-        feature: any;
+        feature: T;
     }>;
     private findUniqueFeature;
 }

package/dist/composed-store.js

@@ -58,7 +58,7 @@ export class ComposedStore {
             .map(([generatorId, generator]) => {
             const { features = generator.getFeatures?.() } = generator;
             const feature = features?.[featureName];
-            return feature ? { generatorId, feature } : undefined;
+            return feature ? { generatorId, feature: feature } : undefined;
         })
             .filter(Boolean);
     }
@@ -68,10 +68,10 @@ export class ComposedStore {
             if (providedFeatures.length > 1) {
                 this.log?.info?.(`Multiple ${featureName} tasks found (${providedFeatures.map(({ generatorId }) => generatorId).join(', ')}). Using the first.`);
             }
-            const { generatorId, feature } = providedFeatures[0];
+            const [{ generatorId, feature }] = providedFeatures;
             debug(`Feature ${featureName} provided by ${generatorId}`);
             return feature;
         }
-        return undefined;
+        return;
     }
 }

package/dist/constants.js

@@ -1,6 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export const UNKNOWN_NAMESPACE = 'unknownnamespace';
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export const UNKNOWN_RESOLVED = 'unknown';
 export const defaultQueues = [
     'environment:run',

package/dist/environment-base.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="node" resolution-mode="require"/>
 import EventEmitter from 'node:events';
 import { QueuedAdapter, type TerminalAdapterOptions } from '@yeoman/adapter';
-import type { ApplyTransformsOptions, BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorConstructor, BaseGeneratorMeta, ComposeOptions, GeneratorMeta, GetGeneratorConstructor, InputOutputAdapter, InstantiateOptions, LookupGeneratorMeta } from '@yeoman/types';
+import type { ApplyTransformsOptions, BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorConstructorMeta, BaseGeneratorMeta, ComposeOptions, GeneratorMeta, GetGeneratorConstructor, InputOutputAdapter, InstantiateOptions, LookupGeneratorMeta } from '@yeoman/types';
 import { type Store as MemFs } from 'mem-fs';
 import { type MemFsEditorFile } from 'mem-fs-editor';
 import { FlyRepository } from 'fly-import';
@@ -9,10 +8,11 @@ import GroupedQueue from 'grouped-queue';
 import { type FilePipelineTransform } from '@yeoman/transform';
 import { type YeomanNamespace } from '@yeoman/namespace';
 import { type ConflicterOptions } from '@yeoman/conflicter';
-import { ComposedStore } from './composed-store.js';
-import Store from './store.js';
-import type YeomanCommand from './util/command.js';
-import { type LookupOptions } from './generator-lookup.js';
+import { ComposedStore } from './composed-store.ts';
+import Store from './store.ts';
+import type YeomanCommand from './util/command.ts';
+import { type LookupOptions } from './generator-lookup.ts';
+import { type InstallTask } from './package-manager.ts';
 export type EnvironmentLookupOptions = LookupOptions & {
     /** Add a scope to the namespace if there is no scope */
     registerToScope?: string;
@@ -54,6 +54,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     protected experimental: boolean;
     protected _rootGenerator?: BaseGenerator;
     protected compatibilityMode?: false | 'v4';
+    private contextStore;
     constructor(options?: EnvironmentOptions);
     findFeature(featureName: string): Array<{
         generatorId: string;
@@ -64,7 +65,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param   namespaceOrPath
      * @return the generator meta registered under the namespace
      */
-    findMeta(namespaceOrPath: string | YeomanNamespace): Promise<GeneratorMeta | undefined>;
+    findMeta(namespaceOrPath: string | YeomanNamespace): 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
@@ -75,7 +76,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param   namespaceOrPath
      * @return the generator registered under the namespace
      */
-    get<C extends BaseGeneratorConstructor = BaseGeneratorConstructor>(namespaceOrPath: string | YeomanNamespace): Promise<C | undefined>;
+    get<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | YeomanNamespace): Promise<(GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined> | ((GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta) | undefined);
     /**
      * Create is the Generator factory. It takes a namespace to lookup and optional
      * hash of options, that lets you define `arguments` and `options` to
@@ -87,7 +88,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param instantiateOptions
      * @return The instantiated generator
      */
-    create<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | GetGeneratorConstructor<G>, instantiateOptions?: InstantiateOptions<G>): Promise<G>;
+    create<G extends BaseGenerator = BaseGenerator>(namespaceOrPath: string | (GetGeneratorConstructor<G> & Partial<BaseGeneratorConstructorMeta>), instantiateOptions?: InstantiateOptions<G>): Promise<G>;
     /**
      * Instantiate a Generator with metadatas
      *
@@ -245,7 +246,7 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
     watchForPackageManagerInstall({ cwd, queueTask, installTask, }?: {
         cwd?: string;
         queueTask?: boolean;
-        installTask?: (nodePackageManager: string | undefined, defaultTask: () => Promise<boolean>) => void | Promise<void>;
+        installTask?: InstallTask;
     }): void;
     /**
      * Start Environment queue
@@ -277,4 +278,9 @@ export default class EnvironmentBase extends EventEmitter implements BaseEnviron
      * @param  packagePath - The generator's package path
      */
     protected registerStub(Generator: any, namespace: string, resolved?: string, packagePath?: string): GeneratorMeta;
+    /**
+     * @experimental
+     * Get a map to store shared data, usually a generator root path to share a map by path.
+     */
+    getContextMap(key: string, factory?: () => Map<string, any>): Map<string, any>;
 }