yeoman-environment 8.3.0 → 8.5.0

package/dist/{util → cli}/command.d.ts

@@ -1,5 +1,5 @@
 import { Command, Option } from 'commander';
-import type BaseEnvironment from '../environment-base.ts';
+import type BaseEnvironment from '../environment/environment-base.ts';
 export default class YeomanCommand extends Command {
     #private;
     env?: BaseEnvironment;

package/dist/{commands.d.ts → cli/commands.d.ts}

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

package/dist/{commands.js → cli/commands.js}

@@ -1,5 +1,5 @@
-import YeomanCommand, { addEnvironmentOptions } from "./util/command.js";
-import { createEnv as createEnvironment } from "./index.js";
+import YeomanCommand, { addEnvironmentOptions } from "./command.js";
+import Environment from "../environment/environment-full.js";
 /**
  * Prepare a commander instance for cli support.
  *
@@ -8,7 +8,7 @@ import { createEnv as createEnvironment } from "./index.js";
  * @return {Command} return command
  */
 export const prepareGeneratorCommand = async ({ command = addEnvironmentOptions(new YeomanCommand()), resolved, generator, namespace, }) => {
-    const environment = createEnvironment();
+    const environment = new Environment();
     let meta;
     if (generator && namespace) {
         meta = environment.register(generator, { namespace, resolved });

package/dist/cli/index.js

@@ -2,8 +2,8 @@ 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 as createEnvironment } from "../index.js";
+import YeomanCommand, { addEnvironmentOptions } from "./command.js";
+import Environment from "../environment/environment-full.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());
@@ -21,14 +21,14 @@ program
     .command('find')
     .description('Find installed generators')
     .action(async () => {
-    const environment = createEnvironment();
+    const environment = new Environment();
     printGroupedGenerator(await environment.lookup());
 });
 program
     .command('list')
     .description('List generators available to be used')
     .action(async () => {
-    const environment = createEnvironment();
+    const environment = new Environment();
     await environment.lookup();
     printGroupedGenerator(Object.values(environment.getGeneratorsMeta()));
 });

package/dist/cli/utils.d.ts

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

package/dist/cli/utils.js

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

package/dist/{commit.d.ts → environment/commit.d.ts}

@@ -1,7 +1,7 @@
 import type { InputOutputAdapter } from '@yeoman/types';
-import { type ConflicterOptions } from '@yeoman/conflicter';
+import type { ConflicterOptions } from '@yeoman/conflicter';
 import type { Store } from 'mem-fs';
-import { type MemFsEditorFile } from 'mem-fs-editor';
+import type { MemFsEditorFile } from 'mem-fs-editor';
 /**
  * Commits the MemFs to the disc.
  */

package/dist/{commit.js → environment/commit.js}

@@ -1,6 +1,4 @@
-import { createConflicterTransform, createYoResolveTransform, forceYoFiles } from '@yeoman/conflicter';
 import createdLogger from 'debug';
-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,5 +7,7 @@ const debug = createdLogger('yeoman:environment:commit');
  */
 export const commitSharedFsTask = async ({ adapter, conflicterOptions, sharedFs, }) => {
     debug('Running commitSharedFsTask');
+    // The conflicter is loaded by the commit only.
+    const { createConflicterTransform, createYoResolveTransform, forceYoFiles } = await import('@yeoman/conflicter');
     await sharedFs.pipeline({ filter: (file) => isFilePending(file) || file.path.endsWith('.yo-resolve') }, createYoResolveTransform(), forceYoFiles(), createConflicterTransform(adapter, conflicterOptions), createCommitTransform());
 };

package/dist/{environment-base.d.ts → environment/environment-base.d.ts}

@@ -2,16 +2,15 @@ import EventEmitter from 'node:events';
 import { QueuedAdapter, type TerminalAdapterOptions } from '@yeoman/adapter';
 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 type { MemFsEditorFile } from 'mem-fs-editor';
 import { FlyRepository } from 'fly-import';
 import GroupedQueue from 'grouped-queue';
 import { type FilePipelineTransform } from '@yeoman/transform';
 import { type YeomanNamespace } from '@yeoman/namespace';
-import { type ConflicterOptions } from '@yeoman/conflicter';
+import type { ConflicterOptions } from '@yeoman/conflicter';
 import { ComposedStore } from './composed-store.ts';
-import Store, { type StoreGeneratorMeta, type StoreSharedLookupOptions } from './store.ts';
-import type YeomanCommand from './util/command.ts';
-import { type LookupOptions } from './generator-lookup.ts';
+import { type LookupOptions, Store, type StoreGeneratorMeta, type StoreSharedLookupOptions } from '../store/index.ts';
+import type YeomanCommand from '../cli/command.ts';
 import { type InstallTask } from './package-manager.ts';
 export type EnvironmentLookupOptions = LookupOptions & {
     /** Add a scope to the namespace if there is no scope */

package/dist/{environment-base.js → environment/environment-base.js}

@@ -4,7 +4,6 @@ import { isAbsolute, join, relative, resolve } from 'node:path';
 import process from 'node:process';
 import { QueuedAdapter } from '@yeoman/adapter';
 import { create as createMemFs } from 'mem-fs';
-import {} from 'mem-fs-editor';
 import { FlyRepository } from 'fly-import';
 import createdLogger from 'debug';
 import GroupedQueue from 'grouped-queue';
@@ -12,17 +11,16 @@ import { isFilePending } from 'mem-fs-editor/state';
 import { filePipeline, transform } from '@yeoman/transform';
 import { toNamespace } from '@yeoman/namespace';
 import chalk from 'chalk';
-import {} from '@yeoman/conflicter';
 import { ComposedStore } from "./composed-store.js";
-import Store, {} from "./store.js";
-import {} from "./generator-lookup.js";
-import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from "./constants.js";
-import { resolveModulePath } from "./util/resolve.js";
+import { Store } from "../store/index.js";
+import { UNKNOWN_NAMESPACE, UNKNOWN_RESOLVED, defaultQueues } from "../constants.js";
+import { resolveModulePath } from "./resolve.js";
 import { commitSharedFsTask } from "./commit.js";
 import { packageManagerInstallTask } from "./package-manager.js";
-import { defaults, pick, splitArgsFromString as splitArgumentsFromString } from "./util/util.js";
+import { splitArgsFromString as splitArgumentsFromString } from "../util/args.js";
+import { defaults, pick } from "../util/object.js";
 const require = createRequire(import.meta.url);
-const ENVIRONMENT_VERSION = require('../package.json').version;
+const ENVIRONMENT_VERSION = require('../../package.json').version;
 const debug = createdLogger('yeoman:environment');
 const getInstantiateOptions = (firstArg, generatorOptions) => {
     // First argument can be an array of string, a string, a ComposeOptions, a GeneratorOptions, old variant of ComposeOptions.

package/dist/{environment-full.d.ts → environment/environment-full.d.ts}

@@ -1,6 +1,6 @@
 import type { BaseGeneratorConstructor, BaseGeneratorOptions, GeneratorEnvironmentOptions, GeneratorMeta } from '@yeoman/types';
-import { type LookupOptions } from './generator-lookup.ts';
 import EnvironmentBase, { type EnvironmentOptions } from './environment-base.ts';
+import { type LookupOptions } from '../store/index.ts';
 declare class FullEnvironment extends EnvironmentBase {
     constructor(options?: EnvironmentOptions);
     /**

package/dist/{environment-full.js → environment/environment-full.js}

@@ -3,11 +3,11 @@ import { join, resolve } from 'node:path';
 import { requireNamespace, toNamespace } from '@yeoman/namespace';
 import { flyImport } from 'fly-import';
 import { valid } from 'semver';
-import {} from "./generator-lookup.js";
-import YeomanCommand from "./util/command.js";
+import YeomanCommand from "../cli/command.js";
 import EnvironmentBase, {} from "./environment-base.js";
-import { defaults, pick, splitArgsFromString as splitArgumentsFromString } from "./util/util.js";
-import { nestedGeneratorsFolder } from "./util/namespace.js";
+import { splitArgsFromString as splitArgumentsFromString } from "../util/args.js";
+import { defaults, pick } from "../util/object.js";
+import { nestedGeneratorsFolder } from "../store/index.js";
 class FullEnvironment extends EnvironmentBase {
     constructor(options = {}, adapterCompat) {
         if (adapterCompat) {

package/dist/{package-manager.js → environment/package-manager.js}

@@ -1,7 +1,5 @@
 import { join, resolve } from 'node:path';
 import createdLogger from 'debug';
-import { whichPackageManager } from 'which-package-manager';
-import { execa } from 'execa';
 const debug = createdLogger('yeoman:environment:package-manager');
 /**
  * Executes package manager install.
@@ -56,7 +54,9 @@ Changes to package.json were detected.`);
 `);
         return false;
     }
-    let packageManagerName = nodePackageManager ?? (await whichPackageManager({ cwd: packageJsonLocation }));
+    // which-package-manager and execa are loaded by an install only.
+    let packageManagerName = nodePackageManager ??
+        (await import('which-package-manager').then(({ whichPackageManager }) => whichPackageManager({ cwd: packageJsonLocation })));
     const execPackageManager = async () => {
         if (!packageManagerName) {
             packageManagerName = 'npm';
@@ -68,6 +68,7 @@ Changes to package.json were detected.`);
         }
         adapter.log(`
 Running ${packageManagerName} install for you to install the required dependencies.`);
+        const { execa } = await import('execa');
         await execa(packageManagerName, ['install'], { stdio: 'inherit', cwd: packageJsonLocation });
         return true;
     };

package/dist/{util → environment}/resolve.js

@@ -2,7 +2,7 @@ import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
 import { realpathSync, statSync } from 'node:fs';
 import untildify from 'untildify';
 import { locatePathSync } from 'locate-path';
-import { defaultExtensions } from "../generator-lookup.js";
+import { defaultExtensions } from "../store/index.js";
 /**
  * Resolve a module path
  * @param  specifier - Filepath or module name

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { type EnvironmentOptions } from './environment-base.ts';
-import Environment from './environment-full.ts';
-export { default } from './environment-full.ts';
-export { default as EnvironmentBase, type EnvironmentOptions } from './environment-base.ts';
-export { default as Store, type StoreEnvironmentOptions, type StoreGeneratorMeta, type StoreLookupGeneratorMeta, type StoreLookupOptions, type StoreSharedLookupOptions, } from './store.ts';
+import type { EnvironmentOptions } from './environment/environment-base.ts';
+import Environment from './environment/environment-full.ts';
+export { default } from './environment/environment-full.ts';
+export { default as EnvironmentBase, type EnvironmentOptions } from './environment/environment-base.ts';
+export { Store, type StoreEnvironmentOptions, type StoreGeneratorMeta, type StoreLookupGeneratorMeta, type StoreLookupOptions, type StoreSharedLookupOptions, } from './store/index.ts';
 export declare const createEnv: (options?: EnvironmentOptions) => Environment;
 export declare const enforceUpdate: () => void;
-export { type CommandPreparation, prepareCommand, prepareGeneratorCommand } from './commands.ts';
-export { addEnvironmentOptions } from './util/command.ts';
-export { type InstallTask, type PackageManagerInstallTaskOptions, packageManagerInstallTask } from './package-manager.ts';
-export { commitSharedFsTask } from './commit.ts';
-export { lookupGenerator } from './generator-lookup.ts';
+export { type CommandPreparation, prepareCommand, prepareGeneratorCommand } from './cli/commands.ts';
+export { addEnvironmentOptions } from './cli/command.ts';
+export { type InstallTask, type PackageManagerInstallTaskOptions, packageManagerInstallTask } from './environment/package-manager.ts';
+export { commitSharedFsTask } from './environment/commit.ts';
+export { lookupGenerator } from './store/index.ts';

package/dist/index.js

@@ -1,14 +1,13 @@
-import {} from "./environment-base.js";
-import Environment from "./environment-full.js";
-export { default } from "./environment-full.js";
-export { default as EnvironmentBase } from "./environment-base.js";
+import Environment from "./environment/environment-full.js";
+export { default } from "./environment/environment-full.js";
+export { default as EnvironmentBase } from "./environment/environment-base.js";
 // Experimental: the Store API is not stable yet.
-export { default as Store, } from "./store.js";
+export { Store, } from "./store/index.js";
 export const createEnv = (options) => new Environment(options);
 // Backward compatibility
 export const enforceUpdate = () => { };
-export { prepareCommand, prepareGeneratorCommand } from "./commands.js";
-export { addEnvironmentOptions } from "./util/command.js";
-export { packageManagerInstallTask } from "./package-manager.js";
-export { commitSharedFsTask } from "./commit.js";
-export { lookupGenerator } from "./generator-lookup.js";
+export { prepareCommand, prepareGeneratorCommand } from "./cli/commands.js";
+export { addEnvironmentOptions } from "./cli/command.js";
+export { packageManagerInstallTask } from "./environment/package-manager.js";
+export { commitSharedFsTask } from "./environment/commit.js";
+export { lookupGenerator } from "./store/index.js";

package/dist/store/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Store, type StoreEnvironmentOptions, type StoreGeneratorMeta, type StoreLookupGeneratorMeta, type StoreLookupOptions, type StoreSharedLookupOptions, } from './store.ts';
+export { type LookupOptions, defaultExtensions, lookupGeneratorsSync } from './lookup.ts';
+export { lookupGenerator } from './lookup-generator.ts';
+export { type ModuleLookupOptions, findPackagesIn, getNpmPaths, moduleLookupSync } from './module-lookup.ts';
+export { asNamespace, defaultLookups, nestedGeneratorsFolder, withNestedLookups } from './namespace.ts';

package/dist/store/index.js

@@ -0,0 +1,6 @@
+// The store and its lookups, for the modules of the package: public.ts is the module of yeoman-environment/store.
+export { default as Store, } from "./store.js";
+export { defaultExtensions, lookupGeneratorsSync } from "./lookup.js";
+export { lookupGenerator } from "./lookup-generator.js";
+export { findPackagesIn, getNpmPaths, moduleLookupSync } from "./module-lookup.js";
+export { asNamespace, defaultLookups, nestedGeneratorsFolder, withNestedLookups } from "./namespace.js";

package/dist/store/lookup-generator.d.ts

@@ -0,0 +1,26 @@
+import { type ModuleLookupOptions } from './module-lookup.ts';
+import type { LookupOptions } from './lookup.ts';
+/**
+ * Lookup for a specific generator.
+ *
+ * @param  {String} namespace
+ * @param  {Object} [options]
+ * @param {Boolean} [options.localOnly=false] - Set true to skip lookups of
+ *                                                     globally-installed generators.
+ * @param {Boolean} [options.packagePath=false] - Set true to return the package
+ *                                                       path instead of generators file.
+ * @param {Boolean} [options.singleResult=true] - Set false to return multiple values.
+ * @return {String} generator
+ */
+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 & Pick<LookupOptions, 'nestedGenerators'> & {
+    packagePath?: boolean;
+    generatorPath?: boolean;
+} & {
+    singleResult: false;
+}): string[];

package/dist/store/lookup-generator.js

@@ -0,0 +1,32 @@
+import { isAbsolute, join, posix } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { requireNamespace, toNamespace } from '@yeoman/namespace';
+import { findPackagesIn, getNpmPaths } from "./module-lookup.js";
+import { defaultLookups, withNestedLookups } from "./namespace.js";
+import Store from "./store.js";
+export function lookupGenerator(namespace, options) {
+    options = typeof options === 'boolean' ? { localOnly: options } : (options ?? {});
+    const { packagePath: returnPackagePath, generatorPath: returnGeneratorPath, singleResult = true, ...lookupOptions } = options;
+    const ns = requireNamespace(namespace);
+    lookupOptions.packagePatterns = lookupOptions.packagePatterns ?? [ns.generatorHint];
+    if (!lookupOptions.packagePaths) {
+        // Looking the npm paths up runs the package managers, skip it when the packages are given.
+        lookupOptions.npmPaths = lookupOptions.npmPaths ?? getNpmPaths({ localOnly: lookupOptions.localOnly }).toReversed();
+        lookupOptions.packagePaths = findPackagesIn(lookupOptions.npmPaths, lookupOptions.packagePatterns);
+    }
+    // The generators are looked up by a store of their own, which keeps the ones asked for.
+    const generators = new Store().lookupSync({
+        filePatterns: withNestedLookups(defaultLookups, lookupOptions.nestedGenerators).map(prefix => join(prefix, '*/index.{js,ts}')),
+        reverse: false,
+        ...lookupOptions,
+        lookups: defaultLookups,
+        singleResult,
+        filter: generator => generator.namespace === namespace || Boolean(returnPackagePath && toNamespace(generator.namespace)?.packageNamespace === namespace),
+    });
+    const paths = generators.map(({ filePath, packagePath }) => {
+        // Version 2.6.0 returned pattern instead of modulePath for options.packagePath
+        const returnPath = returnPackagePath ? packagePath : returnGeneratorPath ? posix.join(filePath, '../../') : filePath;
+        return isAbsolute(returnPath) ? pathToFileURL(returnPath).toString() : returnPath;
+    });
+    return singleResult ? paths[0] : paths;
+}

package/dist/{generator-lookup.d.ts → store/lookup.d.ts}

@@ -42,28 +42,4 @@ export declare function lookupGeneratorsSync(options?: LookupOptions, register?:
     filePath: string;
     packagePath: string;
 }[];
-/**
- * Lookup for a specific generator.
- *
- * @param  {String} namespace
- * @param  {Object} [options]
- * @param {Boolean} [options.localOnly=false] - Set true to skip lookups of
- *                                                     globally-installed generators.
- * @param {Boolean} [options.packagePath=false] - Set true to return the package
- *                                                       path instead of generators file.
- * @param {Boolean} [options.singleResult=true] - Set false to return multiple values.
- * @return {String} generator
- */
-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 & Pick<LookupOptions, 'nestedGenerators'> & {
-    packagePath?: boolean;
-    generatorPath?: boolean;
-} & {
-    singleResult: false;
-}): string[];
 export {};

package/dist/{generator-lookup.js → store/lookup.js}

@@ -1,9 +1,6 @@
-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, withNestedLookups } from "./util/namespace.js";
-import Store from "./store.js";
+import { extname } from 'node:path';
+import { moduleLookupSync } from "./module-lookup.js";
+import { defaultLookups, withNestedLookups } from "./namespace.js";
 export const defaultExtensions = ['.ts', '.cts', '.mts', '.js', '.cjs', '.mjs'];
 /**
  * Search for generators and their sub generators.
@@ -52,29 +49,3 @@ export function lookupGeneratorsSync(options = {}, register) {
         return;
     });
 }
-export function lookupGenerator(namespace, options) {
-    options = typeof options === 'boolean' ? { localOnly: options } : (options ?? {});
-    const { packagePath: returnPackagePath, generatorPath: returnGeneratorPath, singleResult = true, ...lookupOptions } = options;
-    const ns = requireNamespace(namespace);
-    lookupOptions.packagePatterns = lookupOptions.packagePatterns ?? [ns.generatorHint];
-    if (!lookupOptions.packagePaths) {
-        // Looking the npm paths up runs the package managers, skip it when the packages are given.
-        lookupOptions.npmPaths = lookupOptions.npmPaths ?? getNpmPaths({ localOnly: lookupOptions.localOnly }).toReversed();
-        lookupOptions.packagePaths = findPackagesIn(lookupOptions.npmPaths, lookupOptions.packagePatterns);
-    }
-    // The generators are looked up by a store of their own, which keeps the ones asked for.
-    const generators = new Store().lookupSync({
-        filePatterns: withNestedLookups(defaultLookups, lookupOptions.nestedGenerators).map(prefix => join(prefix, '*/index.{js,ts}')),
-        reverse: false,
-        ...lookupOptions,
-        lookups: defaultLookups,
-        singleResult,
-        filter: generator => generator.namespace === namespace || Boolean(returnPackagePath && toNamespace(generator.namespace)?.packageNamespace === namespace),
-    });
-    const paths = generators.map(({ filePath, packagePath }) => {
-        // Version 2.6.0 returned pattern instead of modulePath for options.packagePath
-        const returnPath = returnPackagePath ? packagePath : returnGeneratorPath ? posix.join(filePath, '../../') : filePath;
-        return isAbsolute(returnPath) ? pathToFileURL(returnPath).toString() : returnPath;
-    });
-    return singleResult ? paths[0] : paths;
-}

package/dist/{module-lookup.js → store/module-lookup.js}

@@ -6,10 +6,10 @@ import arrify from 'arrify';
 import { globbySync } from 'globby';
 import slash from 'slash';
 import createdLogger from 'debug';
-import { execaOutput } from "./util/util.js";
+import { execaOutput } from "../util/exec.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '..');
+const PROJECT_ROOT = join(__dirname, '../..');
 const PACKAGE_NAME_PATTERN = [JSON.parse(readFileSync(join(PROJECT_ROOT, 'package.json')).toString()).name];
 const win32 = process.platform === 'win32';
 const nvm = process.env.NVM_HOME;

package/dist/{util → store}/namespace.js

@@ -1,6 +1,6 @@
 import { parse, posix } from 'node:path';
 import slash from 'slash';
-import { escapeRegExp } from "./util.js";
+import { escapeRegExp } from "../util/regexp.js";
 /** The folder holding the generators nested in a generator. */
 export const nestedGeneratorsFolder = 'generators';
 /**

package/dist/store/public.d.ts

@@ -0,0 +1 @@
+export { default, default as Store, type StoreEnvironmentOptions, type StoreGeneratorMeta, type StoreLookupGeneratorMeta, type StoreLookupOptions, type StoreSharedLookupOptions, } from './store.ts';

package/dist/store/public.js

@@ -0,0 +1,2 @@
+// The module of yeoman-environment/store: the store alone, without the environment.
+export { default, default as Store, } from "./store.js";

package/dist/{store.d.ts → store/store.d.ts}

@@ -1,5 +1,5 @@
 import type { BaseEnvironment, BaseGenerator, BaseGeneratorConstructorMeta, BaseGeneratorMeta, GeneratorMeta, GetGeneratorConstructor } from '@yeoman/types';
-import { type LookupOptions } from './generator-lookup.ts';
+import { type LookupOptions } from './lookup.ts';
 type FoundGenerator = {
     namespace: string;
     /** Path of the generator as it was found, `resolved` is its real path. */
@@ -37,6 +37,10 @@ export type StoreLookupGeneratorMeta = FoundGenerator & ((StoreGeneratorMeta & {
 export type StoreGeneratorMeta = Omit<GeneratorMeta, 'importGenerator' | 'instantiate' | 'instantiateHelp'> & {
     /** Require the module `require(meta.resolved)`, throws if the module cannot be required synchronously. */
     requireModule?: () => unknown;
+    /** Require the sibling module of the name, like `command.ts` next to `index.ts`, `undefined` if missing. */
+    requireSibling?: (name: string) => unknown;
+    /** Import the sibling module of the name, like `requireSibling` for a module that can not be required. */
+    importSibling?: (name: string) => Promise<unknown>;
     importGenerator: <G extends BaseGenerator = BaseGenerator>(options?: StoreEnvironmentOptions) => Promise<GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta> | (GetGeneratorConstructor<G> & BaseGeneratorConstructorMeta);
     instantiate: <G extends BaseGenerator = BaseGenerator>(arguments_?: string[], options?: any, environmentOptions?: StoreEnvironmentOptions) => Promise<G>;
     instantiateHelp: <G extends BaseGenerator = BaseGenerator>(options?: StoreEnvironmentOptions) => Promise<G>;

package/dist/{store.js → store/store.js}

@@ -7,19 +7,51 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { pathToFileURL } from 'node:url';
-import { basename, extname, join, relative } from 'node:path';
+import { basename, dirname, extname, join, relative } from 'node:path';
 import { createRequire } from 'node:module';
-import { readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { namespaceFromPackageName, toNamespace } from '@yeoman/namespace';
 import createDebug from 'debug';
-import { lookupGeneratorsSync } from "./generator-lookup.js";
-import { asNamespace, defaultLookups } from "./util/namespace.js";
+import { lookupGeneratorsSync } from "./lookup.js";
+import { asNamespace, defaultLookups } from "./namespace.js";
 const debug = createDebug('yeoman:environment:store');
 const require = createRequire(import.meta.url);
 // The operations of a meta, kept on the meta itself: the meta of a clone has the operations of the meta it was cloned from.
 const operationsKey = Symbol('operations');
 const setOperations = (meta, operations) => Object.defineProperty(meta, operationsKey, { value: operations });
 const getOperations = (meta) => meta[operationsKey];
+/** The functions loading the modules next to a generator module, with its extension. */
+const createSiblingFunctions = (resolved) => {
+    if (typeof resolved !== 'string' || !extname(resolved)) {
+        return {};
+    }
+    const folder = dirname(resolved);
+    const extension = extname(resolved);
+    const siblingPath = (name) => {
+        const filePath = join(folder, `${name}${extension}`);
+        return existsSync(filePath) ? filePath : undefined;
+    };
+    const requireSibling = (name) => {
+        const filePath = siblingPath(name);
+        return filePath ? require(filePath) : undefined;
+    };
+    const importSibling = async (name) => {
+        const filePath = siblingPath(name);
+        if (!filePath) {
+            return undefined;
+        }
+        try {
+            return require(filePath);
+        }
+        catch (error) {
+            if (error.code === 'ERR_REQUIRE_ESM' || error.code === 'ERR_REQUIRE_ASYNC_MODULE') {
+                return import(__rewriteRelativeImportExtension(pathToFileURL(filePath).href));
+            }
+            throw error;
+        }
+    };
+    return { requireSibling, importSibling };
+};
 /** The namespace of a generator package, like `@scope/foo` for `@scope/generator-foo`, undefined for another name. */
 const namespaceOfPackage = (packageName) => {
     try {
@@ -222,6 +254,7 @@ export default class Store {
         generatorMeta = {
             ...meta,
             ...this.createMetaFunctions(operations, () => this.environment),
+            ...createSiblingFunctions(meta.resolved),
             requireModule,
             importModule,
             getPackageJson,

package/dist/util/args.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Two-step argument splitting function that first splits arguments in quotes,
+ * and then splits up the remaining arguments if they are not part of a quote.
+ */
+export declare function splitArgsFromString(argumentsString: string | string[]): string[];

package/dist/util/args.js

@@ -0,0 +1,23 @@
+/**
+ * Two-step argument splitting function that first splits arguments in quotes,
+ * and then splits up the remaining arguments if they are not part of a quote.
+ */
+export function splitArgsFromString(argumentsString) {
+    if (Array.isArray(argumentsString)) {
+        return argumentsString;
+    }
+    let result = [];
+    if (!argumentsString) {
+        return result;
+    }
+    const quoteSeparatedArguments = argumentsString.split(/("[^"]*")/).filter(Boolean);
+    for (const argument of quoteSeparatedArguments) {
+        if (argument.includes('"')) {
+            result.push(argument.replaceAll('"', ''));
+        }
+        else {
+            result = result.concat(argument.trim().split(' '));
+        }
+    }
+    return result;
+}

package/dist/util/exec.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The output of a command, `undefined` when it fails. execa is loaded at the first command only: a lookup given the
+ * paths of its packages runs none, and the store does not load it.
+ */
+export declare const execaOutput: (cmg: string, arguments_: string[]) => string | undefined;

package/dist/util/exec.js

@@ -0,0 +1,19 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+/**
+ * The output of a command, `undefined` when it fails. execa is loaded at the first command only: a lookup given the
+ * paths of its packages runs none, and the store does not load it.
+ */
+export const execaOutput = (cmg, arguments_) => {
+    try {
+        const { execaSync } = require('execa');
+        const { failed, stdout } = execaSync(cmg, arguments_, { encoding: 'utf8' });
+        if (!failed) {
+            return stdout;
+        }
+    }
+    catch {
+        // ignore error
+    }
+    return;
+};

package/dist/util/object.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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;

package/dist/util/object.js

@@ -0,0 +1,20 @@
+/**
+ * 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;
+};

package/dist/util/regexp.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Escape the characters with a meaning in a regular expression, like lodash `escapeRegExp`.
+ */
+export declare const escapeRegExp: (value: string) => string;

package/dist/util/regexp.js

@@ -0,0 +1,4 @@
+/**
+ * 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.3.0",
+  "version": "8.5.0",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",
@@ -28,6 +28,10 @@
       "types": "./dist/index.d.js",
       "default": "./dist/index.js"
     },
+    "./store": {
+      "types": "./dist/store/public.d.ts",
+      "default": "./dist/store/public.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
@@ -52,7 +56,7 @@
     "fix": "eslint --fix && prettier . --write",
     "prepare": "npm run build",
     "pretest": "eslint && prettier . --check && tsc",
-    "test": "c8 --include 'src/**' esmocha --forbid-only"
+    "test": "exnode --coverage"
   },
   "config": {
     "doc_path": "./yeoman-environment-doc"
@@ -84,9 +88,9 @@
     "@types/node": "^26.4.1",
     "@types/semver": "^7.8.0",
     "@yeoman/eslint": "1.1.0",
-    "c8": "^12.0.0",
     "eslint": "10.10.0",
-    "esmocha": "^5.0.0",
+    "expect-node": "^0.3.3",
+    "jest-snapshot": "^30.5.2",
     "jsdoc": "^4.0.5",
     "prettier": "3.9.6",
     "prettier-plugin-packagejson": "^3.0.2",

package/dist/util/util.d.ts

@@ -1,19 +0,0 @@
-export declare const execaOutput: (cmg: string, arguments_: string[]) => string | undefined;
-/**
- * Two-step argument splitting function that first splits arguments in quotes,
- * 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

@@ -1,60 +0,0 @@
-import { execaSync } from 'execa';
-export const execaOutput = (cmg, arguments_) => {
-    try {
-        const { failed, stdout } = execaSync(cmg, arguments_, { encoding: 'utf8' });
-        if (!failed) {
-            return stdout;
-        }
-    }
-    catch {
-        // ignore error
-    }
-    return;
-};
-/**
- * Two-step argument splitting function that first splits arguments in quotes,
- * and then splits up the remaining arguments if they are not part of a quote.
- */
-export function splitArgsFromString(argumentsString) {
-    if (Array.isArray(argumentsString)) {
-        return argumentsString;
-    }
-    let result = [];
-    if (!argumentsString) {
-        return result;
-    }
-    const quoteSeparatedArguments = argumentsString.split(/("[^"]*")/).filter(Boolean);
-    for (const argument of quoteSeparatedArguments) {
-        if (argument.includes('"')) {
-            result.push(argument.replaceAll('"', ''));
-        }
-        else {
-            result = result.concat(argument.trim().split(' '));
-        }
-    }
-    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 `\$&`);