yeoman-test 8.2.0 → 9.0.0

package/README.md

@@ -22,17 +22,16 @@ $ npm install --save-dev yeoman-generator@xxx yeoman-environment@xxx
 
 ## Usage
 
-Usage:
+Usage using the convenience last RunResult instance:
 
 ```js
-import helpers from 'yeoman-test';
+import helpers, { result } from 'yeoman-test';
 
 describe('generator test', () => {
   describe('test', () => {
-    let runResult;
     beforeEach(async () => {
-      runResult = await helpers
-        .create(                   // instantiates RunContext
+      await helpers
+        .run(                   // instantiates RunContext
           'namespace',             // namespace or generator
           {},                      // test options
           {}                       // environment options
@@ -53,47 +52,25 @@ describe('generator test', () => {
         [.withYoRcConfig('generator-foo.bar', { : {} })] // same as above
         [.commitFiles()]            // commit mem-fs files to disk
         [.onGenerator(gen => {})]   // do something with the generator
-        [.onEnvironment(env => {})] // do something with the environment
-        [.build(runContext => {     // instantiates Environment/Generator
-          [runContext.env...]       // does something with the environment
-          [runContext.generator...] // does something with the generator
-        })]
-        .run();                     // runs the environment, promises a RunResult
-      [result.create().run()] // instantiates a new RunContext at the same directory
+        [.onEnvironment(env => {})]; // do something with the environment
+
+      [await result.create('another-generator').run();] // instantiates a new RunContext at the same directory
     );
-    afterEach(() => {
-      if (runResult) {
-        // Optional if context is executed at a temporary folder
-        runResult.restore();
-      }
-    });
+
     it('runs correctly', () => {
       // runs assertions using mem-fs.
-      [runResult.assertFile('file.txt');]
-      [runResult.assertNoFile('file.txt');]
-      [runResult.assertFileContent('file.txt', 'content');]
-      [runResult.assertEqualsFileContent('file.txt', 'content');]
-      [runResult.assertNoFileContent('file.txt', 'content');]
-      [runResult.assertJsonFileContent('file.txt', {});]
-      [runResult.assertNoJsonFileContent('file.txt', {});]
+      [result.assertFile('file.txt');]
+      [result.assertNoFile('file.txt');]
+      [result.assertFileContent('file.txt', 'content');]
+      [result.assertEqualsFileContent('file.txt', 'content');]
+      [result.assertNoFileContent('file.txt', 'content');]
+      [result.assertJsonFileContent('file.txt', {});]
+      [result.assertNoJsonFileContent('file.txt', {});]
     });
   });
 });
 ```
 
-Convenience last RunResult instance:
-
-```js
-import helpers, { result } from 'yeoman-test';
-
-describe('generator test', () => {
-  before(() => helpers.run('namespace'));
-  it('test', () => {
-    result.assert...;
-  });
-});
-```
-
 Generator compose:
 
 ```js

package/dist/adapter.d.ts

@@ -3,3 +3,7 @@ export declare class TestAdapter extends BaseTestAdapter {
     constructor(options?: TestAdapterOptions);
 }
 export { DummyPrompt, type DummyPromptOptions, type DummyPromptCallback, type TestAdapterOptions } from '@yeoman/adapter/testing';
+export type AskedQuestions = Array<{
+    name: string;
+    answer: any;
+}>;

package/dist/adapter.js

@@ -1,13 +1,13 @@
-// eslint-disable-next-line n/file-extension-in-import
+import { mock } from 'node:test';
 import { TestAdapter as BaseTestAdapter } from '@yeoman/adapter/testing';
-import { spy as sinonSpy, stub as sinonStub } from 'sinon';
 export class TestAdapter extends BaseTestAdapter {
     constructor(options = {}) {
         super({
-            spyFactory: ({ returns }) => (returns ? sinonStub().returns(returns) : sinonSpy()),
+            spyFactory: ({ returns }) => returns
+                ? mock.fn(() => { }, () => returns)
+                : mock.fn(),
             ...options,
         });
     }
 }
-// eslint-disable-next-line n/file-extension-in-import
 export { DummyPrompt } from '@yeoman/adapter/testing';

package/dist/default-environment.d.ts

@@ -1 +1 @@
-export function createEnv(options: import('@yeoman/types').BaseEnvironmentOptions): import('@yeoman/types').BaseEnvironment;
+export function createEnv(options: import("@yeoman/types").BaseEnvironmentOptions): import("@yeoman/types").BaseEnvironment;

package/dist/default-environment.js

@@ -3,13 +3,12 @@
  * @returns {import('@yeoman/types').BaseEnvironment}
  */
 export const createEnv = async (options) => {
-    const DynamicEnv = await import('yeoman-environment');
-    if (typeof DynamicEnv === 'function') {
-        return new DynamicEnv(options);
+    const DynamicEnvironment = await import('yeoman-environment');
+    if (typeof DynamicEnvironment === 'function') {
+        return new DynamicEnvironment(options);
     }
-    if (typeof DynamicEnv.default === 'function') {
-        // eslint-disable-next-line new-cap
-        return new DynamicEnv.default(options);
+    if (typeof DynamicEnvironment.default === 'function') {
+        return new DynamicEnvironment.default(options);
     }
     throw new Error(`'yeoman-environment' didn't returned a constructor`);
 };

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
+import { mock } from 'node:test';
 import type { BaseEnvironment, BaseEnvironmentOptions, BaseGenerator, BaseGeneratorOptions, GetGeneratorConstructor, InstantiateOptions, PromptAnswers } from '@yeoman/types';
-import type { SinonSpiedInstance } from 'sinon';
 import type { DefaultEnvironmentApi, DefaultGeneratorApi } from '../types/type-helpers.js';
 import { type DummyPromptOptions, TestAdapter, type TestAdapterOptions } from './adapter.js';
 import RunContext, { BasicRunContext, type RunContextSettings } from './run-context.js';
@@ -38,7 +38,7 @@ export declare class YeomanTest {
      *   fs.writeFileSync('testfile', 'Roses are red.');
      * });
      */
-    testDirectory(dir: string, cb?: (error?: any) => unknown): unknown;
+    testDirectory(dir: string, callback?: (error?: any) => unknown): unknown;
     /**
      * @deprecated
      * Answer prompt questions for the passed-in generator
@@ -50,13 +50,13 @@ export declare class YeomanTest {
      * @example
      * mockPrompt(angular, {'bootstrap': 'Y', 'compassBoostrap': 'Y'});
      */
-    mockPrompt(envOrGenerator: BaseGenerator | DefaultEnvironmentApi, mockedAnswers?: PromptAnswers, options?: DummyPromptOptions): void;
+    mockPrompt(environmentOrGenerator: BaseGenerator | DefaultEnvironmentApi, mockedAnswers?: PromptAnswers, options?: DummyPromptOptions): void;
     /**
      * @deprecated
      * Restore defaults prompts on a generator.
      * @param generator or environment
      */
-    restorePrompt(envOrGenerator: BaseGenerator | DefaultEnvironmentApi): void;
+    restorePrompt(environmentOrGenerator: BaseGenerator | DefaultEnvironmentApi): void;
     /**
      * @deprecated
      * Provide mocked values to the config
@@ -67,11 +67,11 @@ export declare class YeomanTest {
     /**
      * Create a mocked generator
      */
-    createMockedGenerator(GeneratorClass?: any): SinonSpiedInstance<DefaultGeneratorApi>;
+    createMockedGenerator(GeneratorClass?: any): ReturnType<typeof mock.fn>;
     /**
      * Create a simple, dummy generator
      */
-    createDummyGenerator<GenParameter extends BaseGenerator = DefaultGeneratorApi>(Generator?: GetGeneratorConstructor<GenParameter>, contents?: Record<string, (...args: any[]) => void>): new (...args: any[]) => GenParameter;
+    createDummyGenerator<GenParameter extends BaseGenerator = DefaultGeneratorApi>(Generator?: GetGeneratorConstructor<GenParameter>, contents?: Record<string, (...arguments_: any[]) => void>): new (...arguments_: any[]) => GenParameter;
     /**
      * Create a generator, using the given dependencies and controller arguments
      * Dependecies can be path (autodiscovery) or an array [{generator}, {name}]
@@ -118,7 +118,7 @@ export declare class YeomanTest {
      * @param {Object} - Options to be passed to the environment
      * const env = createTestEnv(require('yeoman-environment').createEnv);
      */
-    createTestEnv(envContructor?: CreateEnv, options?: BaseEnvironmentOptions): Promise<BaseEnvironment>;
+    createTestEnv(environmentContructor?: CreateEnv, options?: BaseEnvironmentOptions): Promise<BaseEnvironment>;
     /**
      * Creates a TestAdapter using helpers default options.
      */
@@ -132,13 +132,13 @@ export declare class YeomanTest {
      * Run the provided Generator
      * @param GeneratorOrNamespace - Generator constructor or namespace
      */
-    run<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
+    run<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, environmentOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
     /**
      * Prepare a run context
      * @param  {String|Function} GeneratorOrNamespace - Generator constructor or namespace
      * @return {RunContext}
      */
-    create<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
+    create<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, environmentOptions?: BaseEnvironmentOptions): RunContext<GeneratorType>;
     /**
      * Prepare temporary dir without generator support.
      * Generator and environment will be undefined.

package/dist/helpers.js

@@ -1,18 +1,20 @@
-import { mkdirSync, existsSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { resolve } from 'node:path';
 import process from 'node:process';
+import { mock } from 'node:test';
 import { cloneDeep } from 'lodash-es';
-import { spy as sinonSpy, stub as sinonStub } from 'sinon';
 import { TestAdapter } from './adapter.js';
 import RunContext, { BasicRunContext } from './run-context.js';
 import testContext from './test-context.js';
-import { createEnv } from './default-environment.js';
+import { createEnv as createEnvironment } from './default-environment.js';
 let GeneratorImplementation;
 try {
     const GeneratorImport = await import('yeoman-generator');
     GeneratorImplementation = GeneratorImport.default ?? GeneratorImport;
 }
-catch { }
+catch {
+    // Ignore error
+}
 /**
  * Collection of unit test helpers. (mostly related to Mocha syntax)
  * @class YeomanTest
@@ -47,7 +49,7 @@ export class YeomanTest {
      *   fs.writeFileSync('testfile', 'Roses are red.');
      * });
      */
-    testDirectory(dir, cb) {
+    testDirectory(dir, callback) {
         if (!dir) {
             throw new Error('Missing directory');
         }
@@ -61,10 +63,10 @@ export class YeomanTest {
             }
             mkdirSync(dir, { recursive: true });
             process.chdir(dir);
-            return cb?.();
+            return callback?.();
         }
         catch (error) {
-            return cb?.(error);
+            return callback?.(error);
         }
     }
     /**
@@ -78,8 +80,8 @@ export class YeomanTest {
      * @example
      * mockPrompt(angular, {'bootstrap': 'Y', 'compassBoostrap': 'Y'});
      */
-    mockPrompt(envOrGenerator, mockedAnswers, options) {
-        const environment = 'env' in envOrGenerator ? envOrGenerator.env : envOrGenerator;
+    mockPrompt(environmentOrGenerator, mockedAnswers, options) {
+        const environment = 'env' in environmentOrGenerator ? environmentOrGenerator.env : environmentOrGenerator;
         if (!environment.adapter) {
             throw new Error('environment is not an Environment instance');
         }
@@ -94,8 +96,8 @@ export class YeomanTest {
      * Restore defaults prompts on a generator.
      * @param generator or environment
      */
-    restorePrompt(envOrGenerator) {
-        const environment = envOrGenerator.env ?? envOrGenerator;
+    restorePrompt(environmentOrGenerator) {
+        const environment = environmentOrGenerator.env ?? environmentOrGenerator;
         environment.adapter.close();
     }
     /**
@@ -113,10 +115,10 @@ export class YeomanTest {
     createMockedGenerator(GeneratorClass = GeneratorImplementation) {
         class MockedGenerator extends GeneratorClass {
         }
-        const generator = sinonSpy(MockedGenerator);
+        const generator = mock.fn(MockedGenerator);
         for (const methodName of ['run', 'queueTasks', 'runWithOptions', 'queueOwnTasks']) {
             Object.defineProperty(MockedGenerator.prototype, methodName, {
-                value: sinonStub(),
+                value: mock.fn(),
             });
         }
         return generator;
@@ -130,18 +132,18 @@ export class YeomanTest {
         },
     }) {
         class DummyGenerator extends Generator {
-            constructor(...args) {
-                const optIndex = Array.isArray(args[0]) ? 1 : 0;
-                args[optIndex] = args[optIndex] ?? {};
-                const options = args[optIndex];
+            constructor(...arguments_) {
+                const optIndex = Array.isArray(arguments_[0]) ? 1 : 0;
+                arguments_[optIndex] = arguments_[optIndex] ?? {};
+                const options = arguments_[optIndex];
                 options.namespace = options.namespace ?? 'dummy';
                 options.resolved = options.resolved ?? 'dummy';
-                super(...args);
+                super(...arguments_);
             }
         }
-        for (const [propName, propValue] of Object.entries(contents)) {
-            Object.defineProperty(DummyGenerator.prototype, propName, {
-                value: propValue ?? Object.create(null),
+        for (const [propertyName, propertyValue] of Object.entries(contents)) {
+            Object.defineProperty(DummyGenerator.prototype, propertyName, {
+                value: propertyValue ?? Object.create(null),
                 writable: true,
             });
         }
@@ -168,16 +170,16 @@ export class YeomanTest {
      */
     async createGenerator(name, options = {}) {
         const { dependencies = [], localConfigOnly = true, ...instantiateOptions } = options;
-        const env = await this.createEnv({ sharedOptions: { localConfigOnly } });
+        const environment = await this.createEnv({ sharedOptions: { localConfigOnly } });
         for (const dependency of dependencies) {
             if (typeof dependency === 'string') {
-                env.register(dependency);
+                environment.register(dependency);
             }
             else {
-                env.register(...dependency);
+                environment.register(...dependency);
             }
         }
-        return env.create(name, instantiateOptions);
+        return environment.create(name, instantiateOptions);
     }
     /**
      * Shortcut to the Environment's createEnv.
@@ -195,7 +197,7 @@ export class YeomanTest {
      * });
      */
     async createEnv(options) {
-        return createEnv(options);
+        return createEnvironment(options);
     }
     /**
      * Creates a test environment.
@@ -204,31 +206,31 @@ export class YeomanTest {
      * @param {Object} - Options to be passed to the environment
      * const env = createTestEnv(require('yeoman-environment').createEnv);
      */
-    async createTestEnv(envContructor = this.createEnv, options = { localConfigOnly: true }) {
-        let envOptions = cloneDeep(this.environmentOptions ?? {});
+    async createTestEnv(environmentContructor = this.createEnv, options = { localConfigOnly: true }) {
+        let environmentOptions = cloneDeep(this.environmentOptions ?? {});
         if (typeof options === 'boolean') {
-            envOptions = {
+            environmentOptions = {
                 newErrorHandler: true,
-                ...envOptions,
+                ...environmentOptions,
                 sharedOptions: {
                     localConfigOnly: options,
-                    ...envOptions.sharedOptions,
+                    ...environmentOptions.sharedOptions,
                 },
             };
         }
         else {
-            envOptions.sharedOptions = {
+            environmentOptions.sharedOptions = {
                 localConfigOnly: true,
-                ...envOptions.sharedOptions,
+                ...environmentOptions.sharedOptions,
                 ...options.sharedOptions,
             };
-            envOptions = {
+            environmentOptions = {
                 newErrorHandler: true,
-                ...envOptions,
+                ...environmentOptions,
                 ...options,
             };
         }
-        return envContructor({ adapter: this.createTestAdapter(), ...envOptions });
+        return environmentContructor({ adapter: this.createTestAdapter(), ...environmentOptions });
     }
     /**
      * Creates a TestAdapter using helpers default options.
@@ -247,11 +249,11 @@ export class YeomanTest {
      * Run the provided Generator
      * @param GeneratorOrNamespace - Generator constructor or namespace
      */
-    run(GeneratorOrNamespace, settings, envOptions) {
+    run(GeneratorOrNamespace, settings, environmentOptions) {
         const contextSettings = cloneDeep(this.settings ?? {});
         const generatorOptions = cloneDeep(this.generatorOptions ?? {});
         const RunContext = this.getRunContextType();
-        const runContext = new RunContext(GeneratorOrNamespace, { ...contextSettings, ...settings }, envOptions, this).withOptions(generatorOptions);
+        const runContext = new RunContext(GeneratorOrNamespace, { ...contextSettings, ...settings }, environmentOptions, this).withOptions(generatorOptions);
         if (settings?.autoCleanup !== false) {
             testContext.startNewContext(runContext);
         }
@@ -262,8 +264,8 @@ export class YeomanTest {
      * @param  {String|Function} GeneratorOrNamespace - Generator constructor or namespace
      * @return {RunContext}
      */
-    create(GeneratorOrNamespace, settings, envOptions) {
-        return this.run(GeneratorOrNamespace, settings, envOptions);
+    create(GeneratorOrNamespace, settings, environmentOptions) {
+        return this.run(GeneratorOrNamespace, settings, environmentOptions);
     }
     /**
      * Prepare temporary dir without generator support.

package/dist/mocha-cleanup.hooks.d.ts

@@ -0,0 +1,3 @@
+export namespace mochaHooks {
+    function afterAll(): void;
+}

package/dist/mocha-cleanup.hooks.js

@@ -0,0 +1,6 @@
+import { context } from './index.js';
+export const mochaHooks = {
+    afterAll() {
+        context.startNewContext();
+    },
+};

package/dist/run-context.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from 'node:events';
+import { mock } from 'node:test';
 import { type Store } from 'mem-fs';
-import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor, GetGeneratorOptions, PromptAnswers, LookupOptions } from '@yeoman/types';
-import { type MemFsEditorFile, type MemFsEditor } from 'mem-fs-editor';
-import type { DefaultGeneratorApi, DefaultEnvironmentApi } from '../types/type-helpers.js';
+import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor, GetGeneratorOptions, LookupOptions, PromptAnswers } from '@yeoman/types';
+import { type MemFsEditor, type MemFsEditorFile } from 'mem-fs-editor';
+import type { DefaultEnvironmentApi, DefaultGeneratorApi } from '../types/type-helpers.js';
 import RunResult, { type RunResultOptions } from './run-result.js';
-import { type CreateEnv, type Dependency, type YeomanTest } from './helpers.js';
-import { type DummyPromptOptions, type TestAdapterOptions } from './adapter.js';
+import { type CreateEnv as CreateEnvironment, type Dependency, type YeomanTest } from './helpers.js';
+import { type AskedQuestions, type DummyPromptOptions, type TestAdapterOptions } from './adapter.js';
 /**
  * Provides settings for creating a `RunContext`.
  */
@@ -33,21 +33,22 @@ export type RunContextSettings = {
 };
 type PromiseRunResult<GeneratorType extends BaseGenerator> = Promise<RunResult<GeneratorType>>;
 type MockedGeneratorFactory<GenParameter extends BaseGenerator = DefaultGeneratorApi> = (GeneratorClass?: GetGeneratorConstructor<GenParameter>) => GetGeneratorConstructor<GenParameter>;
-type EnvOptions = BaseEnvironmentOptions & {
-    createEnv?: CreateEnv;
+type EnvironmentOptions = BaseEnvironmentOptions & {
+    createEnv?: CreateEnvironment;
 };
 export declare class RunContextBase<GeneratorType extends BaseGenerator = DefaultGeneratorApi> extends EventEmitter {
     readonly mockedGenerators: Record<string, BaseGenerator>;
     env: DefaultEnvironmentApi;
     generator: GeneratorType;
     readonly settings: RunContextSettings;
-    readonly envOptions: EnvOptions;
+    readonly envOptions: EnvironmentOptions;
     completed: boolean;
     targetDirectory?: string;
     editor: MemFsEditor;
     memFs: Store<MemFsEditorFile>;
     spawnStub?: any;
     mockedGeneratorFactory: MockedGeneratorFactory;
+    readonly askedQuestions: AskedQuestions;
     protected environmentPromise?: PromiseRunResult<GeneratorType>;
     private args;
     private options;
@@ -78,13 +79,13 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param settings
      * @return {this}
      */
-    constructor(generatorType?: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: EnvOptions, helpers?: YeomanTest);
+    constructor(generatorType?: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, environmentOptions?: EnvironmentOptions, helpers?: YeomanTest);
     /**
      * Run the generator on the environment and promises a RunResult instance.
      * @return {PromiseRunResult} Promise a RunResult instance.
      */
     run(): PromiseRunResult<GeneratorType>;
-    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    on(eventName: string | symbol, listener: (...arguments_: any[]) => void): this;
     /**
      * @deprecated
      * Clean the provided directory, then change directory into it
@@ -93,13 +94,13 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param [cb] - callback who'll receive the folder path as argument
      * @return run context instance
      */
-    inDir(dirPath: string, cb?: (folderPath: string) => void): this;
+    inDir(dirPath: string, callback?: (folderPath: string) => void): this;
     /**
      * Register an callback to prepare the destination folder.
      * @param [cb]  - callback who'll receive the folder path as argument
      * @return this - run context instance
      */
-    doInDir(cb: (folderPath: string) => void): this;
+    doInDir(callback: (folderPath: string) => void): this;
     /**
      * @deprecated
      * Change directory without deleting directory content.
@@ -117,7 +118,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param [cb]  - callback who'll receive the folder path as argument
      * @return this - run context instance
      */
-    inTmpDir(cb?: (folderPath: string) => void): this;
+    inTmpDir(callback?: (folderPath: string) => void): this;
     /**
      * Restore cwd to initial cwd.
      * @return {this} run context instance
@@ -151,7 +152,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param {Function} [cb] - callback who'll receive the folder path as argument
      * @return {this} run context instance
      */
-    withEnvironment(cb: any): this;
+    withEnvironment(callback: any): this;
     /**
      * Run lookup on the environment.
      *
@@ -162,7 +163,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * Provide arguments to the run context
      * @param  args - command line arguments as Array or space separated string
      */
-    withArguments(args: string | string[]): this;
+    withArguments(arguments_: string | string[]): this;
     /**
      * Provide options to the run context
      * @param  {Object} options - command line options (e.g. `--opt-one=foo`)
@@ -203,10 +204,13 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * });
      */
     withGenerators(dependencies: Dependency[]): this;
-    withSpawnMock(options?: ((...args: any[]) => any) | {
-        stub?: (...args: any[]) => any;
-        registerSinonDefaults?: boolean;
-        callback?: (stub: any) => void | Promise<void>;
+    withSpawnMock<StubType = ReturnType<typeof mock.fn>>(options?: ((...arguments_: any[]) => any) | {
+        stub?: (...arguments_: any[]) => any;
+        registerNodeMockDefaults?: boolean;
+        callback?: ({ stub, implementation }: {
+            stub: StubType;
+            implementation: any;
+        }) => void | Promise<void>;
     }): this;
     withMockedGeneratorFactory(mockedGeneratorFactory: MockedGeneratorFactory): this;
     /**
@@ -282,7 +286,7 @@ export declare class RunContextBase<GeneratorType extends BaseGenerator = Defaul
      * @param callback
      * @returns
      */
-    onEnvironment(callback: (this: this, env: DefaultEnvironmentApi) => any): this;
+    onEnvironment(callback: (this: this, environment: DefaultEnvironmentApi) => any): this;
     prepare(): Promise<void>;
     protected assertNotBuild(): void;
     /**

package/dist/run-context.js

@@ -1,20 +1,18 @@
 import crypto from 'node:crypto';
 import { existsSync, rmSync } from 'node:fs';
-import path, { resolve, isAbsolute, join as pathJoin } from 'node:path';
+import path, { isAbsolute, join as pathJoin, resolve } from 'node:path';
 import assert from 'node:assert';
 import { EventEmitter } from 'node:events';
 import process from 'node:process';
+import { mock } from 'node:test';
 import { camelCase, kebabCase, merge as lodashMerge, set as lodashSet } from 'lodash-es';
-// eslint-disable-next-line n/file-extension-in-import
 import { resetFileCommitStates } from 'mem-fs-editor/state';
 import { create as createMemFs } from 'mem-fs';
 import tempDirectory from 'temp-dir';
-import { stub as sinonStub } from 'sinon';
 import { create as createMemFsEditor } from 'mem-fs-editor';
 import RunResult from './run-result.js';
 import defaultHelpers from './helpers.js';
 import testContext from './test-context.js';
-// eslint-disable-next-line unicorn/prefer-event-target
 export class RunContextBase extends EventEmitter {
     mockedGenerators = {};
     env;
@@ -27,6 +25,7 @@ export class RunContextBase extends EventEmitter {
     memFs;
     spawnStub;
     mockedGeneratorFactory;
+    askedQuestions = [];
     environmentPromise;
     args = [];
     options = {};
@@ -57,13 +56,13 @@ export class RunContextBase extends EventEmitter {
      * @param settings
      * @return {this}
      */
-    constructor(generatorType, settings, envOptions = {}, helpers = defaultHelpers) {
+    constructor(generatorType, settings, environmentOptions = {}, helpers = defaultHelpers) {
         super();
         this.settings = {
             ...settings,
         };
         this.Generator = generatorType;
-        this.envOptions = envOptions;
+        this.envOptions = environmentOptions;
         this.oldCwd = this.settings.oldCwd;
         if (this.settings.cwd) {
             this.cd(this.settings.cwd);
@@ -97,7 +96,6 @@ export class RunContextBase extends EventEmitter {
         super.on(eventName, listener);
         // Don't setup emitters if on generator envent.
         if (eventName !== 'generator') {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.setupEventListeners();
         }
         return this;
@@ -110,9 +108,9 @@ export class RunContextBase extends EventEmitter {
      * @param [cb] - callback who'll receive the folder path as argument
      * @return run context instance
      */
-    inDir(dirPath, cb) {
+    inDir(dirPath, callback) {
         this.setDir(dirPath, true);
-        this.helpers.testDirectory(dirPath, () => cb?.call(this, path.resolve(dirPath)));
+        this.helpers.testDirectory(dirPath, () => callback?.call(this, path.resolve(dirPath)));
         return this;
     }
     /**
@@ -120,8 +118,8 @@ export class RunContextBase extends EventEmitter {
      * @param [cb]  - callback who'll receive the folder path as argument
      * @return this - run context instance
      */
-    doInDir(cb) {
-        this.inDirCallbacks.push(cb);
+    doInDir(callback) {
+        this.inDirCallbacks.push(callback);
         return this;
     }
     /**
@@ -152,8 +150,8 @@ export class RunContextBase extends EventEmitter {
      * @param [cb]  - callback who'll receive the folder path as argument
      * @return this - run context instance
      */
-    inTmpDir(cb) {
-        return this.inDir(this.temporaryDir, cb);
+    inTmpDir(callback) {
+        return this.inDir(this.temporaryDir, callback);
     }
     /**
      * Restore cwd to initial cwd.
@@ -213,8 +211,8 @@ export class RunContextBase extends EventEmitter {
      * @param {Function} [cb] - callback who'll receive the folder path as argument
      * @return {this} run context instance
      */
-    withEnvironment(cb) {
-        this.envCB = cb;
+    withEnvironment(callback) {
+        this.envCB = callback;
         return this;
     }
     /**
@@ -223,11 +221,10 @@ export class RunContextBase extends EventEmitter {
      * @param lookups - lookup to run.
      */
     withLookups(lookups) {
-        return this.onEnvironment(async (env) => {
+        return this.onEnvironment(async (environment) => {
             lookups = Array.isArray(lookups) ? lookups : [lookups];
             for (const lookup of lookups) {
-                // eslint-disable-next-line no-await-in-loop
-                await env.lookup(lookup);
+                await environment.lookup(lookup);
             }
         });
     }
@@ -235,10 +232,10 @@ export class RunContextBase extends EventEmitter {
      * Provide arguments to the run context
      * @param  args - command line arguments as Array or space separated string
      */
-    withArguments(args) {
-        const argsArray = typeof args === 'string' ? args.split(' ') : args;
-        assert(Array.isArray(argsArray), 'args should be either a string separated by spaces or an array');
-        this.args = this.args.concat(argsArray);
+    withArguments(arguments_) {
+        const argumentsArray = typeof arguments_ === 'string' ? arguments_.split(' ') : arguments_;
+        assert(Array.isArray(argumentsArray), 'args should be either a string separated by spaces or an array');
+        this.args = [...this.args, ...argumentsArray];
         return this;
     }
     /**
@@ -300,13 +297,13 @@ export class RunContextBase extends EventEmitter {
      */
     withGenerators(dependencies) {
         assert(Array.isArray(dependencies), 'dependencies should be an array');
-        return this.onEnvironment(async (env) => {
+        return this.onEnvironment(async (environment) => {
             for (const dependency of dependencies) {
                 if (typeof dependency === 'string') {
-                    env.register(dependency);
+                    environment.register(dependency);
                 }
                 else {
-                    env.register(...dependency);
+                    environment.register(...dependency);
                 }
             }
         });
@@ -315,31 +312,33 @@ export class RunContextBase extends EventEmitter {
         if (this.spawnStub) {
             throw new Error('Multiple withSpawnMock calls');
         }
-        const stub = typeof options === 'function' ? options : options?.stub ?? sinonStub();
-        const registerSinonDefaults = typeof options === 'function' ? false : options?.registerSinonDefaults ?? true;
-        const callback = typeof options === 'function' ? undefined : options?.callback;
-        if (registerSinonDefaults) {
-            // eslint-disable-next-line @typescript-eslint/no-empty-function
+        const registerNodeMockDefaults = typeof options === 'function' ? false : (options?.registerNodeMockDefaults ?? true);
+        let implementation;
+        if (registerNodeMockDefaults) {
             const defaultChild = { stdout: { on() { } }, stderr: { on() { } } };
             const defaultReturn = { exitCode: 0, stdout: '', stderr: '' };
-            const stubFn = stub;
-            // eslint-disable-next-line @typescript-eslint/promise-function-async
-            stubFn.withArgs('spawnCommand').callsFake(() => Object.assign(Promise.resolve({ ...defaultReturn }), defaultChild));
-            // eslint-disable-next-line @typescript-eslint/promise-function-async
-            stubFn.withArgs('spawn').callsFake(() => Object.assign(Promise.resolve({ ...defaultReturn }), defaultChild));
-            stubFn.withArgs('spawnCommandSync').callsFake(() => ({ ...defaultReturn }));
-            stubFn.withArgs('spawnSync').callsFake(() => ({ ...defaultReturn }));
+            implementation = (...arguments_) => {
+                const [methodName] = arguments_;
+                if (methodName === 'spawnCommand' || methodName === 'spawn') {
+                    return Object.assign(Promise.resolve({ ...defaultReturn }), defaultChild);
+                }
+                if (methodName === 'spawnCommandSync' || methodName === 'spawnSync') {
+                    return { ...defaultReturn };
+                }
+            };
         }
+        const stub = typeof options === 'function' ? options : (options?.stub ?? mock.fn(() => { }, implementation));
+        const callback = typeof options === 'function' ? undefined : options?.callback;
         if (callback) {
             this.onBeforePrepare(async () => {
-                await callback(stub);
+                await callback({ stub, implementation });
             });
         }
         this.spawnStub = stub;
-        return this.onEnvironment(env => {
-            env.on('compose', (_namespace, generator) => {
-                const createCallback = method => function (...args) {
-                    return stub.call(this, method, ...args);
+        return this.onEnvironment(environment => {
+            environment.on('compose', (_namespace, generator) => {
+                const createCallback = method => function (...arguments_) {
+                    return stub.call(this, method, ...arguments_);
                 };
                 generator.spawnCommand = createCallback('spawnCommand');
                 generator.spawnCommandSync = createCallback('spawnCommandSync');
@@ -476,9 +475,8 @@ export class RunContextBase extends EventEmitter {
     }
     async prepare() {
         if (this.beforePrepareCallbacks.length > 0) {
-            for (const cb of this.beforePrepareCallbacks) {
-                // eslint-disable-next-line no-await-in-loop
-                await cb.call(this);
+            for (const callback of this.beforePrepareCallbacks) {
+                await callback.call(this);
             }
         }
         this.assertNotBuild();
@@ -491,9 +489,8 @@ export class RunContextBase extends EventEmitter {
         }
         if (this.inDirCallbacks.length > 0) {
             const targetDirectory = path.resolve(this.targetDirectory);
-            for (const cb of this.inDirCallbacks) {
-                // eslint-disable-next-line no-await-in-loop
-                await cb(targetDirectory);
+            for (const callback of this.inDirCallbacks) {
+                await callback(targetDirectory);
             }
         }
         if (!this.targetDirectory) {
@@ -506,7 +503,6 @@ export class RunContextBase extends EventEmitter {
         }
         this.editor = createMemFsEditor(this.memFs);
         for (const onTargetDirectory of this.onTargetDirectoryCallbacks) {
-            // eslint-disable-next-line no-await-in-loop
             await onTargetDirectory.call(this, this.targetDirectory);
         }
     }
@@ -519,21 +515,27 @@ export class RunContextBase extends EventEmitter {
      * Build the generator and the environment.
      * @return {RunContext|false} this
      */
-    // eslint-disable-next-line @typescript-eslint/member-ordering
     async build() {
         await this.prepare();
-        const testEnv = await this.helpers.createTestEnv(this.envOptions.createEnv, {
+        const { askedQuestions, adapterOptions } = this;
+        const promptCallback = function (answer, options) {
+            const { question } = options;
+            if (question.name) {
+                askedQuestions.push({ name: question.name, answer });
+            }
+            return adapterOptions?.callback ? adapterOptions.callback.call(this, answer, options) : answer;
+        };
+        const testEnvironment = await this.helpers.createTestEnv(this.envOptions.createEnv, {
             cwd: this.settings.forwardCwd ? this.targetDirectory : undefined,
             sharedFs: this.memFs,
             force: true,
             skipCache: true,
             skipInstall: true,
-            adapter: this.helpers.createTestAdapter({ ...this.adapterOptions, mockedAnswers: this.answers }),
+            adapter: this.helpers.createTestAdapter({ ...this.adapterOptions, mockedAnswers: this.answers, callback: promptCallback }),
             ...this.envOptions,
         });
-        this.env = this.envCB ? (await this.envCB(testEnv)) ?? testEnv : testEnv;
+        this.env = this.envCB ? ((await this.envCB(testEnvironment)) ?? testEnvironment) : testEnvironment;
         for (const onEnvironmentCallback of this.onEnvironmentCallbacks) {
-            // eslint-disable-next-line no-await-in-loop
             await onEnvironmentCallback.call(this, this.env);
         }
         const { namespace = typeof this.Generator === 'string' ? this.env.namespace(this.Generator) : 'gen:test' } = this.settings;
@@ -555,7 +557,6 @@ export class RunContextBase extends EventEmitter {
             },
         });
         for (const onGeneratorCallback of this.onGeneratorCallbacks) {
-            // eslint-disable-next-line no-await-in-loop
             await onGeneratorCallback.call(this, this.generator);
         }
     }
@@ -580,6 +581,7 @@ export class RunContextBase extends EventEmitter {
             envOptions: this.envOptions,
             mockedGenerators: this.mockedGenerators,
             helpers: this.helpers,
+            askedQuestions: this.askedQuestions,
         };
     }
     /**
@@ -596,8 +598,7 @@ export class RunContextBase extends EventEmitter {
             .catch(error => {
             if (this.listenerCount('end') === 0 && this.listenerCount('error') === 0) {
                 // When there is no listeners throw a unhandled rejection.
-                setImmediate(async function () {
-                    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+                setImmediate(async () => {
                     throw error;
                 });
             }
@@ -631,7 +632,6 @@ export class RunContextBase extends EventEmitter {
     }
 }
 export default class RunContext extends RunContextBase {
-    // eslint-disable-next-line unicorn/no-thenable
     async then(onfulfilled, onrejected) {
         return this.toPromise().then(onfulfilled, onrejected);
     }

package/dist/run-result.d.ts

@@ -1,9 +1,10 @@
 import type { Store } from 'mem-fs';
-import { type MemFsEditorFile, type MemFsEditor } from 'mem-fs-editor';
+import { type MemFsEditor, type MemFsEditorFile } from 'mem-fs-editor';
 import type { BaseEnvironmentOptions, BaseGenerator, GetGeneratorConstructor } from '@yeoman/types';
 import type { DefaultEnvironmentApi, DefaultGeneratorApi } from '../types/type-helpers.js';
 import { type RunContextSettings } from './run-context.js';
 import { type YeomanTest } from './helpers.js';
+import { type AskedQuestions } from './adapter.js';
 /**
  * Provides options for `RunResult`s.
  */
@@ -34,6 +35,7 @@ export type RunResultOptions<GeneratorType extends BaseGenerator> = {
     spawnStub?: any;
     settings: RunContextSettings;
     helpers: YeomanTest;
+    askedQuestions: AskedQuestions;
 };
 /**
  * This class provides utilities for testing generated content.
@@ -48,13 +50,14 @@ export default class RunResult<GeneratorType extends BaseGenerator = BaseGenerat
     mockedGenerators: any;
     options: RunResultOptions<GeneratorType>;
     spawnStub?: any;
+    readonly askedQuestions: AskedQuestions;
     constructor(options: RunResultOptions<GeneratorType>);
     /**
      * Create another RunContext reusing the settings.
      * See helpers.create api
      */
-    create<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, envOptions?: BaseEnvironmentOptions): import("./run-context.js").default<GeneratorType>;
-    getSpawnArgsUsingDefaultImplementation(): any;
+    create<GeneratorType extends BaseGenerator = DefaultGeneratorApi>(GeneratorOrNamespace: string | GetGeneratorConstructor<GeneratorType>, settings?: RunContextSettings, environmentOptions?: BaseEnvironmentOptions): import("./run-context.js").default<GeneratorType>;
+    getSpawnArgsUsingDefaultImplementation(): unknown[][];
     /**
      * Return an object with fs changes.
      * @param {Function} filter - parameter forwarded to mem-fs-editor#dump

package/dist/run-result.js

@@ -4,13 +4,13 @@ import path from 'node:path';
 import process from 'node:process';
 import { create as createMemFsEditor } from 'mem-fs-editor';
 const isObject = object => typeof object === 'object' && object !== null && object !== undefined;
-function convertArgs(args) {
-    if (args.length > 1) {
-        return [[...args]];
+const convertArguments = arguments_ => {
+    if (arguments_.length > 1) {
+        return [[...arguments_]];
     }
-    const arg = args[0];
-    return Array.isArray(arg) ? arg : [arg];
-}
+    const [argument] = arguments_;
+    return Array.isArray(argument) ? argument : [argument];
+};
 /**
  * This class provides utilities for testing generated content.
  */
@@ -24,6 +24,7 @@ export default class RunResult {
     mockedGenerators;
     options;
     spawnStub;
+    askedQuestions;
     constructor(options) {
         if (options.memFs && !options.cwd) {
             throw new Error('CWD option is required for mem-fs tests');
@@ -36,13 +37,14 @@ export default class RunResult {
         this.fs = this.memFs && createMemFsEditor(this.memFs);
         this.mockedGenerators = options.mockedGenerators || {};
         this.spawnStub = options.spawnStub;
+        this.askedQuestions = options.askedQuestions;
         this.options = options;
     }
     /**
      * Create another RunContext reusing the settings.
      * See helpers.create api
      */
-    create(GeneratorOrNamespace, settings, envOptions) {
+    create(GeneratorOrNamespace, settings, environmentOptions) {
         return this.options.helpers.create(GeneratorOrNamespace, {
             ...this.options.settings,
             cwd: this.cwd,
@@ -50,13 +52,13 @@ export default class RunResult {
             memFs: this.memFs,
             ...settings,
             autoCleanup: false,
-        }, { ...this.options.envOptions, ...envOptions });
+        }, { ...this.options.envOptions, ...environmentOptions });
     }
     getSpawnArgsUsingDefaultImplementation() {
         if (!this.spawnStub) {
             throw new Error('Spawn stub was not found');
         }
-        return this.spawnStub.getCalls().map(call => call.args);
+        return this.spawnStub.mock.calls.map(call => call.arguments);
     }
     /**
      * Return an object with fs changes.
@@ -152,7 +154,7 @@ export default class RunResult {
      * result.assertFile(['templates/user.hbs', 'templates/user/edit.hbs']);
      */
     assertFile(path) {
-        for (const file of convertArgs([path])) {
+        for (const file of convertArguments([path])) {
             const here = this._exists(file);
             assert.ok(here, `${file}, no such file or directory`);
         }
@@ -171,15 +173,14 @@ export default class RunResult {
      * result.assertNoFile(['templates/user.hbs', 'templates/user/edit.hbs']);
      */
     assertNoFile(files) {
-        for (const file of convertArgs([files])) {
+        for (const file of convertArguments([files])) {
             const here = this._exists(file);
             assert.ok(!here, `${file} exists`);
         }
     }
-    assertFileContent(...args) {
-        for (const pair of convertArgs(args)) {
-            const file = pair[0];
-            const regex = pair[1];
+    assertFileContent(...arguments_) {
+        for (const pair of convertArguments(arguments_)) {
+            const [file, regex] = pair;
             this.assertFile(file);
             const body = this._readFile(file);
             let match = false;
@@ -187,18 +188,16 @@ export default class RunResult {
             assert(match, `${file} did not match '${regex}'. Contained:\n\n${body}`);
         }
     }
-    assertEqualsFileContent(...args) {
-        for (const pair of convertArgs(args)) {
-            const file = pair[0];
-            const expectedContent = pair[1];
+    assertEqualsFileContent(...arguments_) {
+        for (const pair of convertArguments(arguments_)) {
+            const [file, expectedContent] = pair;
             this.assertFile(file);
             this.assertTextEqual(this._readFile(file), expectedContent);
         }
     }
-    assertNoFileContent(...args) {
-        for (const pair of convertArgs(args)) {
-            const file = pair[0];
-            const regex = pair[1];
+    assertNoFileContent(...arguments_) {
+        for (const pair of convertArguments(arguments_)) {
+            const [file, regex] = pair;
             this.assertFile(file);
             const body = this._readFile(file);
             if (typeof regex === 'string') {

package/dist/test-context.d.ts

@@ -1,9 +1,11 @@
-import type RunContext from './run-context.js';
 import type RunResult from './run-result.js';
 declare class TestContext {
+    beforeCwd?: string;
+    autoRestore: boolean;
+    autoCleanup?: boolean;
     runResult?: RunResult;
     private runContext?;
-    startNewContext(runContext?: RunContext<any>): void;
+    startNewContext(runContext?: any, autoCleanup?: boolean): void;
 }
 declare const testContext: TestContext;
 export default testContext;

package/dist/test-context.js

@@ -1,27 +1,40 @@
 import process from 'node:process';
+import { onExit } from 'signal-exit';
 class TestContext {
+    beforeCwd;
+    autoRestore = true;
+    autoCleanup;
     runResult;
     runContext;
-    startNewContext(runContext) {
-        this.runContext?.cleanupTemporaryDir();
+    startNewContext(runContext, autoCleanup = true) {
+        if (this.beforeCwd !== process.cwd()) {
+            if (this.autoCleanup) {
+                this.runContext?.cleanupTemporaryDir();
+            }
+            else if (this.autoRestore) {
+                this.runContext?.restore();
+            }
+        }
+        if (this.beforeCwd && this.beforeCwd !== process.cwd()) {
+            console.log('Test failed to restore context', this.beforeCwd, process.cwd());
+        }
+        this.autoCleanup = autoCleanup;
+        this.beforeCwd = runContext ? process.cwd() : undefined;
         this.runContext = runContext;
         this.runResult = undefined;
     }
 }
 const testContext = new TestContext();
-const cleanupTemporaryDir = () => {
+onExit(() => {
     testContext.startNewContext();
-};
-process.on('exit', cleanupTemporaryDir);
-process.on('SIGINT', cleanupTemporaryDir);
-process.on('SIGTERM', cleanupTemporaryDir);
+});
 export default testContext;
 const handler2 = {
-    get(_target, prop, receiver) {
+    get(_target, property, receiver) {
         if (testContext.runResult === undefined) {
             throw new Error('Last result is missing.');
         }
-        return Reflect.get(testContext.runResult, prop, receiver);
+        return Reflect.get(testContext.runResult, property, receiver);
     },
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-test",
-  "version": "8.2.0",
+  "version": "9.0.0",
   "description": "Test utilities for Yeoman generators",
   "keywords": [
     "yeoman",
@@ -12,8 +12,13 @@
   "author": "The Yeoman Team",
   "type": "module",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.js"
+    "./mocha-cleanup": {
+      "import": "./dist/mocha-cleanup.hooks.js"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -27,52 +32,45 @@
     "doc:fix": "sed -i -e 's:^[[:space:]]*<!--[[:space:]]*$::g' -e 's:^[[:space:]]*-->[[:space:]]*$::g' $npm_package_config_doc_path/global.html",
     "doc:generate": "jsdoc -c jsdoc.json -d $npm_package_config_doc_path",
     "doc:prettier": "prettier $npm_package_config_doc_path --write --ignore-path .prettierignore-doc",
+    "fix": "prettier . --write && eslint . --fix",
     "precommit": "lint-staged",
-    "prepare": "npm run build",
-    "pretest": "xo",
-    "test": "c8 esmocha --forbid-only"
+    "prepare": "npm run build && husky",
+    "pretest": "eslint .",
+    "test": "vitest run --coverage"
   },
   "config": {
     "doc_path": "../yeoman-test-doc"
   },
   "dependencies": {
-    "@yeoman/adapter": "^1.4.0",
-    "inquirer": "^9.2.2",
+    "@yeoman/adapter": "^1.6.0",
     "lodash-es": "^4.17.21",
-    "mem-fs-editor": "^10.0.3",
-    "sinon": "^16.0.0",
+    "mem-fs-editor": "^11.1.1",
+    "signal-exit": "^4.1.0",
     "temp-dir": "^3.0.0",
-    "type-fest": "^4.3.1"
+    "type-fest": "^4.25.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.3",
-    "@types/lodash": "^4.14.195",
-    "@types/node": "^16.18.19",
-    "@types/sinon": "^10.0.13",
-    "c8": "^8.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^18.19.46",
+    "@vitest/coverage-v8": "^2.0.5",
+    "@yeoman/eslint": "0.2.0",
     "coveralls": "^3.1.1",
-    "esmocha": "^1.0.1",
-    "husky": "^8.0.2",
+    "husky": "^9.1.5",
     "jsdoc": "^4.0.2",
-    "lint-staged": "^14.0.1",
-    "prettier": "^3.0.3",
+    "lint-staged": "^15.2.9",
+    "prettier": "^3.3.3",
     "prettier-plugin-packagejson": "^2.3.0",
     "tui-jsdoc-template": "^1.2.2",
-    "typescript": "~5.2.2",
-    "xo": "0.56.0",
-    "yeoman-environment": "^3.18.3",
-    "yeoman-generator": "^5.9.0"
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5",
+    "yeoman-environment": "^4.4.1",
+    "yeoman-generator": "^7.3.2"
   },
   "peerDependencies": {
-    "@yeoman/types": "^1.1.0",
-    "mem-fs": "^3.0.0",
-    "yeoman-environment": "^3.18.3",
-    "yeoman-generator": "^5.9.0 || >=6.0.0"
-  },
-  "acceptDependencies": {
-    "mem-fs": "^4.0.0-beta.1",
-    "yeoman-environment": ">=4.0.0-beta.6",
-    "yeoman-generator": ">=6.0.0"
+    "@yeoman/types": "^1.4.0",
+    "mem-fs": "^4.1.0",
+    "yeoman-environment": "^4.0.0",
+    "yeoman-generator": "^7.0.0"
   },
   "peerDependenciesMeta": {
     "yeoman-environment": {
@@ -83,6 +81,6 @@
     }
   },
   "engines": {
-    "node": "^16.17.0 || >=18.12.0"
+    "node": "^18.19.0 || >= 20.6.1"
   }
 }

package/types/type-helpers.d.ts

@@ -1,6 +1,6 @@
-import type { BaseGenerator, BaseEnvironment } from '@yeoman/types';
+import type { BaseEnvironment, BaseGenerator } from '@yeoman/types';
 import type GeneratorImplementation from 'yeoman-generator';
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import type EnvironmentImplementation from 'yeoman-environment';
 import type { IfAny } from 'type-fest';