yeoman-environment 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/environment.d.ts

@@ -1,409 +0,0 @@
-export default Environment;
-declare class Environment {
-    static get UNKNOWN_NAMESPACE(): string;
-    static get UNKNOWN_RESOLVED(): string;
-    static get queues(): string[];
-    static get lookups(): string[];
-    /**
-     * Make sure the Environment present expected methods if an old version is
-     * passed to a Generator.
-     * @param  {Environment} env
-     * @return {Environment} The updated env
-     */
-    static enforceUpdate(env: Environment): Environment;
-    /**
-     * Prepare a commander instance for cli support.
-     *
-     * @param {Class} GeneratorClass - Generator to create Command
-     * @return {Command} Return a Command instance
-     */
-    static prepareCommand(GeneratorClass: Class, command?: YeomanCommand): Command;
-    /**
-     * Prepare a commander instance for cli support.
-     *
-     * @param {Command} command - Command to be prepared
-     * @param {Class} GeneratorClass - Generator to create Command
-     * @return {Command} return command
-     */
-    static prepareGeneratorCommand(command: Command, GeneratorClass: Class, namespace: any): Command;
-    /**
-     * Factory method to create an environment instance. Take same parameters as the
-     * Environment constructor.
-     *
-     * @deprecated
-     * @param {string[]} [args] - arguments.
-     * @param {object} [options] - Environment options.
-     * @param {Adapter} [adapter] - Terminal adapter.
-     *
-     * @return {Environment} a new Environment instance
-     */
-    static createEnv(args?: string[] | undefined, options?: object | undefined, adapter?: any): Environment;
-    /**
-     * Factory method to create an environment instance. Take same parameters as the
-     * Environment constructor.
-     *
-     * @param {String} version - Version of the Environment
-     * @param {...any} args - Same arguments as {@link Environment}#createEnv.
-     * @return {Environment} a new Environment instance
-     */
-    static createEnvWithVersion(version: string, ...args: any[]): Environment;
-    /**
-     * Convert a generators namespace to its name
-     *
-     * @param  {String} namespace
-     * @return {String}
-     */
-    static namespaceToName(namespace: string): 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
-     */
-    static lookupGenerator(namespace: string, options?: {
-        localOnly?: boolean | undefined;
-        packagePath?: boolean | undefined;
-        singleResult?: boolean | undefined;
-    } | undefined): string;
-    /**
-     * @classdesc `Environment` object is responsible of handling the lifecyle and bootstrap
-     * of generators in a specific environment (your app).
-     *
-     * It provides a high-level API to create and run generators, as well as further
-     * tuning where and how a generator is resolved.
-     *
-     * An environment is created using a list of `arguments` and a Hash of
-     * `options`. Usually, this is the list of arguments you get back from your CLI
-     * options parser.
-     *
-     * An optional adapter can be passed to provide interaction in non-CLI environment
-     * (e.g. IDE plugins), otherwise a `TerminalAdapter` is instantiated by default
-     *
-     * @constructor
-     * @implements {import('@yeoman/types').BaseEnvironment}
-     * @mixes env/resolver
-     * @mixes env/composability
-     * @param {String|Array}          args
-     * @param {Object}                opts
-     * @param {Boolean} [opts.experimental]
-     * @param {Object} [opts.sharedOptions]
-     * @param {Console}      [opts.console]
-     * @param {Stream}         [opts.stdin]
-     * @param {Stream}        [opts.stdout]
-     * @param {Stream}        [opts.stderr]
-     * @param {TerminalAdapter} [adapter] - A TerminalAdapter instance or another object
-     *                                     implementing this adapter interface. This is how
-     *                                     you'd interface Yeoman with a GUI or an editor.
-     */
-    constructor(options: any, adapter?: TerminalAdapter | undefined);
-    options: any;
-    adapter: TerminalAdapter;
-    cwd: string;
-    logCwd: any;
-    store: Store;
-    command: any;
-    runLoop: any;
-    sharedFs: any;
-    fs: import("mem-fs-editor").MemFsEditor<import("mem-fs-editor").VinylMemFsEditorFile>;
-    lookups: string[];
-    aliases: any[];
-    sharedOptions: any;
-    repository: YeomanRepository;
-    _generatorsForPath: {};
-    _generators: {};
-    _composeStore: {};
-    enableConflicterIgnore: boolean;
-    /**
-     * Load options passed to the Generator that should be used by the Environment.
-     *
-     * @param {Object} options
-     */
-    loadEnvironmentOptions(options: Object): Partial<Object>;
-    /**
-     * Load options passed to the Environment that should be forwarded to the Generator.
-     *
-     * @param {Object} options
-     */
-    loadSharedOptions(options: Object): Partial<Object>;
-    /**
-     * @deprecated
-     * Error handler taking `err` instance of Error.
-     *
-     * The `error` event is emitted with the error object, if no `error` listener
-     * is registered, then we throw the error.
-     *
-     * @param  {Object} err
-     * @return {Error}  err
-     */
-    error(error: any): Error;
-    /**
-     * Outputs the general help and usage. Optionally, if generators have been
-     * registered, the list of available generators is also displayed.
-     *
-     * @param {String} name
-     */
-    help(name?: string): string;
-    /**
-     * Registers a specific `generator` to this environment. This generator is stored under
-     * provided namespace, or a default namespace format if none if available.
-     *
-     * @param  {String} name      - Filepath to the a generator or a npm package name
-     * @param  {String} namespace - Namespace under which register the generator (optional)
-     * @param  {String} packagePath - PackagePath to the generator npm package (optional)
-     * @return {Object} environment - This environment
-     */
-    register(name: string, namespace: string, packagePath: string): Object;
-    /**
-     * Register a stubbed generator to this environment. This method allow to register raw
-     * functions under the provided namespace. `registerStub` will enforce the function passed
-     * to extend the Base generator automatically.
-     *
-     * @param  {Function} Generator  - A Generator constructor or a simple function
-     * @param  {String}   namespace  - Namespace under which register the generator
-     * @param  {String}   [resolved] - The file path to the generator
-     * @param  {String} [packagePath] - The generator's package path
-     * @return {this}
-     */
-    registerStub(Generator: Function, namespace: string, resolved?: string | undefined, packagePath?: string | undefined): this;
-    /**
-     * Returns the list of registered namespace.
-     * @return {Array}
-     */
-    namespaces(): any[];
-    /**
-     * Returns the environment or dependency version.
-     * @param  {String} packageName - Module to get version.
-     * @return {String} Environment version.
-     */
-    getVersion(packageName: string): string;
-    /**
-     * Returns stored generators meta
-     * @return {Object}
-     */
-    getGeneratorsMeta(): Object;
-    /**
-     * Returns stored generators meta
-     * @param {string} namespace
-     * @return {any}
-     */
-    getGeneratorMeta(namespace: string): any;
-    /**
-     * Get registered generators names
-     *
-     * @return {Array}
-     */
-    getGeneratorNames(): any[];
-    /**
-     * Verify if a package namespace already have been registered.
-     *
-     * @param  {String} [packageNS] - namespace of the package.
-     * @return {boolean} - true if any generator of the package has been registered
-     */
-    isPackageRegistered(packageNS?: string | undefined): boolean;
-    /**
-     * Get all registered packages namespaces.
-     *
-     * @return {Array} - array of namespaces.
-     */
-    getRegisteredPackages(): any[];
-    /**
-     * Get last added path for a namespace
-     *
-     * @param  {String} - namespace
-     * @return {String} - path of the package
-     */
-    getPackagePath(namespace: any): string;
-    /**
-     * Get paths for a namespace
-     *
-     * @param  {String} - namespace
-     * @return  {Array} - array of paths.
-     */
-    getPackagePaths(namespace: any): any[];
-    /**
-     * Get a single generator from the registered list of generators. The lookup is
-     * based on generator's namespace, "walking up" the namespaces until a matching
-     * 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).
-     *
-     * @param  {String} namespaceOrPath
-     * @return {import('@yeoman/api').BaseGenerator|Promise<import('@yeoman/api').BaseGenerator>|null} - the generator registered under the namespace
-     */
-    get(namespaceOrPath: string): any | Promise<any> | null;
-    /**
-     * Get a generator by path instead of namespace.
-     * @param  {String} path
-     * @return {Generator|null} - the generator found at the location
-     */
-    getByPath(path: string): Generator | null;
-    /**
-     * Find generator's class constructor.
-     * @private
-     * @param  {Object} Generator - Object containing the class.
-     * @return {Function} Generator's constructor.
-     */
-    private _findGeneratorClass;
-    /**
-     * Create is the Generator factory. It takes a namespace to lookup and optional
-     * hash of options, that lets you define `arguments` and `options` to
-     * instantiate the generator with.
-     *
-     * An error is raised on invalid namespace.
-     *
-     * @param {String} namespaceOrPath
-     * @param {Array} [args]
-     * @param {Object} [options]
-     * @return {Generator} The instantiated generator
-     */
-    create(namespaceOrPath: string, args?: any[] | undefined, options?: Object | undefined): Generator;
-    /**
-     * Instantiate a Generator with metadatas
-     *
-     * @param {Class<Generator>} generator   Generator class
-     * @param {Array}            [args]      Arguments to pass the instance
-     * @param {Object}           [options]   Options to pass the instance
-     * @return {Generator}       The instantiated generator
-     */
-    instantiate(Generator: any, args?: any[] | undefined, options?: Object | undefined): Generator;
-    /**
-     * Compose with the generator.
-     *
-     * @param {String} namespaceOrPath
-     * @param {Array} [args]
-     * @param {Object} [options]
-     * @param {Boolean} [schedule]
-     * @return {Generator} The instantiated generator or the singleton instance.
-     */
-    composeWith(generator: any, args?: any[] | undefined, options?: Object | undefined, schedule?: boolean | undefined): Generator;
-    /**
-     * @private
-     */
-    private getGeneratorsForPath;
-    /**
-     * @private
-     */
-    private getGenerator;
-    /**
-     * @private
-     */
-    private getAllGenerators;
-    /**
-     * @private
-     */
-    private setGenerator;
-    /**
-     * Queue generator run (queue itself tasks).
-     *
-     * @param {Generator} generator Generator instance
-     * @param {boolean} [schedule=false] Whether to schedule the generator run.
-     * @return {Generator} The generator or singleton instance.
-     */
-    queueGenerator(generator: Generator, schedule?: boolean | undefined): Generator;
-    /**
-     * 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.
-     *
-     * @param {String|Array} args
-     * @param {Object}       [options]
-     */
-    run(args: string | any[], options?: Object | undefined, done: any): Promise<any>;
-    /**
-     * Start Environment queue
-     * @param {Object} options - Conflicter options.
-     */
-    start(options: Object): Promise<any>;
-    conflicter: Conflicter | undefined;
-    /**
-     * Convenience method to run the generator with callbackWrapper.
-     * See https://github.com/yeoman/environment/pull/101
-     *
-     * @param {Object}       generator
-     */
-    runGenerator(generator: Object): Promise<any>;
-    compatibilityMode: string | boolean | undefined;
-    _rootGenerator: any;
-    /**
-     * Get the first generator that was queued to run in this environment.
-     *
-     * @return {Generator} generator queued to run in this environment.
-     */
-    rootGenerator(): Generator;
-    /**
-     * Given a String `filepath`, tries to figure out the relative namespace.
-     *
-     * ### Examples:
-     *
-     *     this.namespace('backbone/all/index.js');
-     *     // => backbone:all
-     *
-     *     this.namespace('generator-backbone/model');
-     *     // => backbone:model
-     *
-     *     this.namespace('backbone.js');
-     *     // => backbone
-     *
-     *     this.namespace('generator-mocha/backbone/model/index.js');
-     *     // => mocha:backbone:model
-     *
-     * @param {String} filepath
-     * @param {Array} lookups paths
-     */
-    namespace(filepath: string, lookups?: any[]): string;
-    /**
-     * Resolve a module path
-     * @param  {String} moduleId - Filepath or module name
-     * @return {String}          - The resolved path leading to the module
-     */
-    resolveModulePath(moduleId: string): string;
-    /**
-     * Apply transform streams to file in MemFs.
-     * @param {Transform[]} transformStreams - transform streams to be applied.
-     * @param {Stream} [stream] - files stream, defaults to this.sharedFs.stream().
-     * @return {Promise<void>}
-     */
-    applyTransforms(transformStreams: Transform[], options?: {}): Promise<void>;
-    /**
-     * Commits the MemFs to the disc.
-     * @param {Stream} [stream] - files stream, defaults to this.sharedFs.stream().
-     * @return {Promise}
-     */
-    commitSharedFs(stream?: any): Promise<any>;
-    /**
-     * Queue environment's commit task.
-     */
-    queueConflicter(): void;
-    /**
-     * Queue environment's package manager install task.
-     */
-    queuePackageManagerInstall(): void;
-    /**
-     * Queue tasks
-     * @param {string} priority
-     * @param {(...args: any[]) => void | Promise<void>} task
-     * @param {{ once?: string, startQueue?: boolean }} [options]
-     */
-    queueTask(priority: string, task: (...args: any[]) => void | Promise<void>, options?: {
-        once?: string | undefined;
-        startQueue?: boolean | undefined;
-    } | undefined): Promise<any>;
-    /**
-     * Add priority
-     * @param {string} priority
-     * @param {string} [before]
-     */
-    addPriority(priority: string, before?: string | undefined): void;
-}
-import TerminalAdapter from './adapter.js';
-import Store from './store.js';
-import YeomanRepository from './util/repository.js';
-import Conflicter from './util/conflicter.js';
-import YeomanCommand from './util/command.js';