@types/yeoman-environment

constructor

constructor(
    args?: string | string[],
    opts?: Environment.Options,
    adapter?: TerminalAdapter
);

• Initializes a new instance of the Environment class.

  Parameter args

  The arguments to pass to the environment.

  Parameter opts

  The options for the environment.

  Parameter adapter

  A TerminalAdapter instance for handling input/output.

property adapter

adapter: TerminalAdapter;

• The adapter of the environment.

property aliases

aliases: Environment.Alias[];

• The alias-settings of the environment.

property arguments

arguments: string[];

• The arguments passed to this environment.

property cwd

cwd: string;

• The working-directory of the environment.

property lookups

lookups: string[];

• The file-paths to look for generators (such as lib/generators/).

property options

options: Environment.Options;

• The options of the environment.

property sharedFs

sharedFs: MemFsStore;

• The file-system of the environment.

property store

store: Storage;

• The config-storage of the environment.

property util

static util: typeof util;

• The utilities of the module.

method alias

alias: { (name: string): string; (match: string | RegExp, value: string): void };

• Gets the alias for the specified name.

• Creates an alias.

  Alias allows the get() and lookup() methods to search in alternate filepath for a given namespaces. It's used for example to map generator-* npm package to their namespace equivalent (without the generator- prefix), or to default a single namespace like angular to angular:app or angular:all.

  If multiple aliases are defined, then the replacement is recursive, replacing each alias in reverse order.

  An alias can be a single String or a Regular Expression. The finding is done based on .match().

  Parameter match

  The name to match.

  Parameter value

  The replacement for the specified match.

  Example 1

  env.alias(/^([a-zA-Z0-9:*]+)$/, 'generator-$1'); env.alias(/^([^:]+)$/, '$1:app'); env.alias(/^([^:]+)$/, '$1:all'); env.alias('foo'); // => generator-foo:all

method applyTransforms

applyTransforms: (
    transformStreams: Transform[],
    stream?: NodeJS.ReadableStream
) => Promise<void>;

• Applies the specified transform streams to the files in the sharedFs.

  Parameter transformStreams

  The transforms to apply.

  Parameter stream

  The file stream to apply the transforms on.

method commitSharedFs

commitSharedFs: (stream: Stream) => Promise<void>;

• Commits the mem-fs to the disk.

  Parameter stream

  The files to commit.

method composeWith

composeWith: (
    namespaceOrPath: string,
    args: string[],
    options: Generator.GeneratorOptions
) => Generator;

• Composes with a generator.

  Parameter namespaceOrPath

  The namespace of the generator or the path to a generator.

  Parameter args

  The options to pass to the generator.

  Parameter options

  The options to pass to the generator.

  Returns

  The instantiated generator or a singleton instance.

method create

create: <TOptions extends Generator.GeneratorOptions>(
    namespaceOrPath: string,
    args: string[],
    options?: Environment.InstantiateOptions<TOptions>
) => Generator<TOptions> | Error;

• Creates a new generator.

  Parameter namespaceOrPath

  The namespace of the generator or the path to a generator.

  Parameter args

  The arguments to pass to the generator.

  Parameter options

  The options to pass to the generator.

  Returns

  Either the newly created generator or the error that occurred.

method createEnv

static createEnv: <TOptions extends Environment.Options = Environment.Options>(
    args?: string | string[],
    opts?: TOptions,
    adapter?: Environment.Adapter
) => Environment<TOptions>;

• Creates a new Environment instance.

  Parameter args

  The arguments to pass to the environment.

  Parameter opts

  The options for the environment.

  Parameter adapter

  A TerminalAdapter instance for handling input/output.

  Returns

  The newly created environment.

method createEnvWithVersion

static createEnvWithVersion: <TOptions extends Environment.Options>(
    version: string,
    args?: string | string[],
    opts?: TOptions,
    adapter?: Environment.Adapter
) => Environment<TOptions>;

• Creates a new Environment instance with the specified version.

  Parameter version

  The version of the environment.

  Parameter args

  The arguments to pass to the environment.

  Parameter opts

  The options for the environment.

  Parameter adapter

  A TerminalAdapter instance for handling input/output.

  Returns

  The newly created environment.

method enforceUpdate

static enforceUpdate: <TEnv extends Environment<Environment.Options>>(
    env: TEnv
) => TEnv;

• Makes sure the Environment present expected methods if an old version is passed to a Generator.

  Parameter env

  The environment to update.

  Returns

  The updated env.

method error

error: (error: Error | object) => Error;

• Handles the specified error.

  The error-event is emitted with the specified error object. If no error listener is registered, the error is thrown.

  Parameter error

  An object representing the error.

method findGeneratorsIn

findGeneratorsIn: (
    list: string[],
    options?: Environment.GeneratorsInOptions
) => string[];

• Searches npm for every available generator. Generators are npm-packages whose name starts with generator- and that are placed in the top level node_module path. They can be installed globally or locally.

  Parameter list

  The paths to search for generators.

  Parameter options

  The options for looking for generators.

  Deprecated

method get

get: (namespaceOrPath: string) => typeof Generator | undefined;

• Gets a single constructor of a generator from the registered list of generators.

  The lookup is based on generator's namespace, "walking up" the namespaces until a matching is found. Eg. if an angular:common namespace is registered, and we try to get angular:common:all, then we get angular:common as a fallback (unless an angular:common:all generator is registered).

  Parameter namespaceOrPath

  The namespace of the generator or the path to a generator.

  Returns

  The constructor of the generator registered under the namespace.

method getByPath

getByPath: (path: string) => typeof Generator | undefined;

• Gets a constructor of a generator by the path instead of the namespace.

  Parameter path

  The path to the generator.

  Returns

  The constructor of the generator found at the location.

method getGeneratorNames

getGeneratorNames: () => string[];

• Gets the names of the registered generators.

method getGeneratorsMeta

getGeneratorsMeta: () => Record<string, Environment.GeneratorMeta>;

• Gets metadata of the registered generators.

method getNpmPaths

getNpmPaths: (options?: Environment.NpmPathsOptions) => string[];

• Gets paths to directories to look for npm-packages (such as ./node_modules).

  Deprecated

method getPackagePath

getPackagePath: (namespace: string) => string;

• Gets the most recent path to the generator by its namespace.

  Parameter namespace

  The namespace of the generator.

method getPackagePaths

getPackagePaths: (namespace: string) => string[];

• Gets all paths which have been populated for a generator by its namespace.

  Parameter namespace

  The namespace of the generator.

method getRegisteredPackages

getRegisteredPackages: () => string[];

• Gets the namespaces of all registered generators.

method getVersion

getVersion: { (): string; (dependency: string): string };

• Gets the version of this Environment object.

• Gets the version of the specified dependency.

  Parameter dependency

  The name of the dependency.

method help

help: (command?: string) => string;

• Outputs general help and usage for the specified command. Optionally, if generators have been registered, a list of available generators is displayed.

  Parameter command

  `The name of the command to get help for.

method installLocalGenerators

installLocalGenerators: (packages: Record<string, string>) => boolean;

• Installs generators at the custom local repository and registers them.

  Parameter packages

  The package-names with the corresponding versions to install.

method instantiate

instantiate: (
    generator: Generator.GeneratorConstructor,
    args: string[],
    options: Environment.InstantiateOptions
) => Generator;

• Instantiates a generator.

  Parameter generator

  The constructor of the generator.

  Parameter args

  The arguments to pass to the generator.

  Parameter options

  The options to pass to the generator.

method isPackageRegistered

isPackageRegistered: (packageNamespace?: string) => boolean;

• Checks whether a package with the specified packageNamespace has been registered.

  Parameter packageNamespace

  The package-namespace to check.

  Returns

  A value indicating whether a package with the specified packageNamespace has been registered.

method loadEnvironmentOptions

loadEnvironmentOptions: (options: Environment.Options) => Environment.Options;

• Applies the specified options to the environment.

  Parameter options

  The options to load.

  Returns

  The new options of the environment.

method loadSharedOptions

loadSharedOptions: (
    options: Generator.GeneratorOptions
) => Generator.GeneratorOptions;

• Loads the specified options into the environment for passing to the generators.

  Parameter options

  The options to load. the new shared options of the environment.

method lookup

lookup: (
    options?: Environment.LookupOptions
) => Environment.LookupGeneratorMeta[];

• Searches for generators and their sub-generators.

  A generator is a :lookup/:name/index.js file placed inside an npm package.

  Default lookups are: - ./ - ./generators/ - ./lib/generators/

  So the index file node_modules/generator-dummy/lib/generators/yo/index.js would be registered as dummy:yo generator.

  Parameter options

  The options for the lookup.

  Returns

  A list of generators.

method lookupGenerator

static lookupGenerator: {
    (
        namespace: string,
        options?: Environment.ArrayGeneratorLookupOptions
    ): string[];
    (
        namespace: string,
        options?: Environment.SingleGeneratorLookupOptions
    ): string;
};

• Invokes a lookup for a specific generator.

  Parameter namespace

  The namespace of the generator to search.

  Parameter options

  Options for searching the generator.

  Returns

  The paths to the generators which were found.

• Invokes a lookup for a specific generator.

  Parameter namespace

  The namespace of the generator to search.

  Parameter options

  Options for searching the generator.

  Returns

  The path to the generator which was found.

method lookupLocalPackages

lookupLocalPackages: (
    packagesToLookup?: string[]
) => Environment.LookupGeneratorMeta[];

• Searches and registers generators inside the custom local repository.

  Parameter packagesToLookup

  The patterns of the packages to lookup.

method namespace

namespace: (filePath: string, lookups?: string[]) => string;

• Converts the specified filePath to a namespace.

  Parameter filePath

  The path to convert.

  Parameter lookups

  The path-part to exclude (such as lib/generators).

method namespaces

namespaces: () => string[];

• Gets a list of all registered namespaces.

method namespaceToName

static namespaceToName: (namespace: string) => string;

• Converts a generator namespace to its name.

  Parameter namespace

  The generator namespace.

method prepareCommand

static prepareCommand: (
    generatorClass: Generator.GeneratorConstructor
) => Command;

• Prepares a command for cli support.

  Parameter generatorClass

  The generator class to create a command for.

  Returns

  The prepared command.

method prepareGeneratorCommand

static prepareGeneratorCommand: (
    command: Command,
    generatorClass: Generator.GeneratorConstructor
) => Command;

• Prepares a command for cli support.

  Parameter command

  The command to prepare.

  Parameter generatorClass

  The constructor of the generator to prepare the command for.

  Returns

  The prepared command.

method queueConflicter

queueConflicter: () => void;

• Queue's the environment's commit task.

method queueGenerator

queueGenerator: (generator: Generator, schedule?: boolean) => Generator;

• Queues the specified generator.

  Parameter generator

  The generator to queue.

  Parameter schedule

  A value indicating whether the execution of the generator should be scheduled.

  Returns

  The queued generator.

method queuePackageManagerInstall

queuePackageManagerInstall: () => void;

• Queues the package manager installation task.

method register

register: (name: string, namespace?: string, packagePath?: string) => this;

• Registers a specific generator to this environment. This generator is stored under the provided namespace or, if not specified, a default namespace format.

  Parameter name

  The filepath to the generator or an npm package name.

  Parameter namespace

  The namespace under which the generator should be registered.

  Parameter packagePath

  The path to the npm package of the generator.

method registerStub

registerStub: (
    generator: Generator.GeneratorConstructor,
    namespace: string,
    resolved?: string,
    packagePath?: string
) => this;

• Registers a stubbed generator to this environment.

  Parameter generator

  The generator constructor.

  Parameter namespace

  The namespace under which the generator should be registered.

  Parameter resolved

  The file-path to the generator.

  Parameter packagePath

  The path to the npm package of the generator.

method resolveModulePath

resolveModulePath: (moduleId: string) => string;

• Resolves the path of the specified module.

  Parameter moduleId

  The name of the module.

  Returns

  The resolved path to the module.

method resolvePackage

resolvePackage: (
    packageName: string,
    packageVersion: string
) => [string, string];

• Resolves a package name with a specific version.

  Parameter packageName

  The name of the package to resolve.

  Parameter packageVersion

  The version or the version range of the package to resolve.

method rootGenerator

rootGenerator: () => Generator;

• Gets the first generator that was queued to run in this environment.

method run

run: (
    args: string | [string, ...string[]],
    options?: Generator.GeneratorOptions
) => Promise<void>;

• Tries to locate and run a specific generator. The lookup is done depending on the provided arguments, options and the list of registered generators.

  When the environment was unable to resolve a generator, an error is raised.

  Parameter args

  The arguments to pass to the generator.

  Parameter options

  The options to pass to the generator.

method runGenerator

runGenerator: (generator: Generator) => Promise<void>;

• Runs the specified generator.

  See [#101](https://github.com/yeoman/environment/pull/101) for more info.

  Parameter generator

  The generator to run.

method spawnCommand

spawnCommand: (
    command: string,
    args: string[],
    options: Options
) => ExecaChildProcess;

• Spawns a command asynchronously.

  Parameter command

  The command to execute.

  Parameter args

  The arguments to pass to the program.

  Parameter options

  The options to use for running the command.

method spawnCommandSync

spawnCommandSync: (
    command: string,
    args: string[],
    options: SyncOptions
) => ExecaSyncReturnValue;

• Spawns a command synchronously.

  Parameter command

  The command to execute.

  Parameter args

  The arguments to pass to the program.

  Parameter options

  The options to use for running the command.

method start

start: (options: Conflicter.ConflicterOptions) => Promise<void>;

• Starts the environment queue.

  Parameter options

  The conflicter options.

property match

match: RegExp;

• The pattern to match.

property value

value: string;

• The replacement of the match.

property singleResult

singleResult?: false | undefined;

property packagePath

packagePath?: boolean | undefined;

• A value indicating whether the path to the package should be returned instead of the path to the generator.

property singleResult

singleResult?: boolean | undefined;

• A value indicating whether only one result should be returned.

property namespace

namespace: string;

• The namespace of the generator.

property packagePath

packagePath: string;

• The path to the package containing the generator.

property resolved

resolved: string;

• The resolved path to the generator.

property packagePatterns

packagePatterns?: string[] | undefined;

• The package-patterns to look for.

property arguments

arguments?: string | string[] | undefined;

• The arguments to pass to the generator.

property options

options?: TOptions | undefined;

• The options for creating the generator.

property registered

registered: boolean;

• A value indicating whether the generator could be registered.

property localOnly

localOnly?: boolean | undefined;

• A value indicating whether globally installed packages should be ignored.

property filePatterns

filePatterns?: string[] | undefined;

• The file-patterns to look for.

property globbyDeep

globbyDeep?: number | undefined;

• The deep option to pass to globby.

property npmPaths

npmPaths?: string[] | undefined;

• The repüository paths to look for generator packages.

property packagePaths

packagePaths?: string[] | undefined;

• The paths to look for generators.

property packagePatterns

packagePatterns?: string[] | undefined;

• The package patterns to look for.

property singleResult

singleResult?: boolean | undefined;

• A value indicating whether the lookup should be stopped after finding the first result.

property filterPaths

filterPaths?: boolean | undefined;

• A value indicating whether paths which don't end with a supported directory-name should be filtered (unless they are part of NODE_PATH).

property console

console?: Console;

• A console instance for logging messages.

property cwd

cwd?: string | undefined;

• The working-directory of the environment.

property experimental

experimental?: boolean;

• A value indicating whether the experimental features should be enabled.

property sharedOptions

sharedOptions?: Generator.GeneratorOptions;

• The options to pass to generators.

property stderr

stderr?: Stream;

• A stream to write error messages to.

property stdin

stdin?: Stream;

• A stream for receiving data from.

property stdout

stdout?: Stream;

• A stream to write normal messages to.

index signature

[key: string]: any;

• Additional options.

property singleResult

singleResult: true;