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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.5",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",

package/dist/adapter.d.ts

@@ -1,54 +0,0 @@
-export default TerminalAdapter;
-declare class TerminalAdapter {
-    /**
-     * `TerminalAdapter` is the default implementation of `Adapter`, an abstraction
-     * layer that defines the I/O interactions.
-     *
-     * It provides a CLI interaction
-     *
-     * @constructor
-     * @param {Object}          [options]
-     * @param {Console} [options.console]
-     */
-    constructor(options?: {
-        console?: Console | undefined;
-    } | undefined);
-    promptModule: any;
-    console: Console;
-    log: {
-        (message: any, ctx: any, ...args: any[]): any;
-        write(...args: any[]): any;
-        writeln(...args: any[]): any;
-        ok(...args: any[]): any;
-        error(...args: any[]): any;
-        table(options: any): string;
-    };
-    tracker: any;
-    get _colorDiffAdded(): import("chalk").ChalkInstance;
-    get _colorDiffRemoved(): import("chalk").ChalkInstance;
-    _colorLines(name: any, string: any): any;
-    close(): void;
-    /**
-     * Prompt a user for one or more questions and pass
-     * the answer(s) to the provided callback.
-     *
-     * It shares its interface with `Base.prompt`
-     *
-     * (Defined inside the constructor to keep interfaces separated between
-     * instances)
-     *
-     * @param {Object|Object[]} questions
-     * @param {Object} [answers] Answers to be passed to inquirer
-     * @return {Object} promise answers
-     */
-    prompt(questions: Object | Object[], answers?: Object | undefined, cb: any): Object;
-    promptUi: any;
-    /**
-     * Shows a color-based diff of two strings
-     *
-     * @param {string} actual
-     * @param {string} expected
-     * @param {Array} changes returned by diff.
-     */
-    diff(actual: string, expected: string, changes: any[]): string;
-}

package/dist/cli/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/utils.d.ts

@@ -1,8 +0,0 @@
-export declare const printGroupedGenerator: (generators: any) => void;
-/**
- * @param {string} generatorNamespace
- * @param {*} options
- * @param {*} command
- * @returns
- */
-export declare const environmentAction: (this: any, generatorNamespace: string, options: any, command: any) => Promise<any>;

package/dist/command.d.ts

@@ -1,24 +0,0 @@
-export default commandMixin;
-declare function commandMixin(cls: any): {
-    new (): {
-        [x: string]: any;
-        /**
-         * Generate a command for the generator and execute.
-         *
-         * @param {string} generatorNamespace
-         * @param {string[]} args
-         */
-        execute(generatorNamespace: string, args?: string[]): Promise<any>;
-    };
-    [x: string]: any;
-    addEnvironmentOptions(command?: YeomanCommand): YeomanCommand;
-    /**
-     * Load Generator options into a commander instance.
-     *
-     * @param {Command} command - Command to load options
-     * @param {Generator} generator - Generator
-     * @return {Command} return command
-     */
-    addGeneratorOptions(command: Command, generator: Generator): Command;
-};
-import YeomanCommand from './util/command.js';

package/dist/composability.d.ts

@@ -1,25 +0,0 @@
-export default composability;
-declare namespace composability {
-    function requireGenerator(namespace: any): Promise<any>;
-    /**
-     * Install generators at the custom local repository and register.
-     *
-     * @param  {Object} packages - packages to install key(packageName): value(versionRange).
-     * @return  {Boolean} - true if the install succeeded.
-     */
-    function installLocalGenerators(packages: Object): boolean;
-    /**
-     * Lookup and register generators from the custom local repository.
-     *
-     * @param  {String[]} [packagesToLookup='generator-*'] - packages to lookup.
-     */
-    function lookupLocalPackages(packagesToLookup?: string[] | undefined): void;
-    /**
-     * Resolve a package name with version.
-     *
-     * @param  {string} packageName - package to resolve.
-     * @param  {string} [packageVersion] - version or range to resolve.
-     * @param  {string[]} Array of key, value pairs.
-     */
-    function resolvePackage(packageName: string, packageVersion?: string | undefined): Promise<any[] | undefined>;
-}

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';

package/dist/generator-features.d.ts

@@ -1,39 +0,0 @@
-export default generatorFeaturesMixin;
-declare function generatorFeaturesMixin(cls: any): {
-    new (): {
-        [x: string]: any;
-        /**
-         * @private
-         * Get generators features.
-         * @return {Object} Namespace, features map.
-         */
-        getGeneratorsFeatures(): Object;
-        /**
-         * @private
-         * Get generators feature.
-         * @param {string} featureName.
-         * @return {Object} Namespace, features map.
-         */
-        getGeneratorsFeature(featureName: any): Object;
-        /**
-         * @private
-         * Find for commit tasks.
-         * @param {string} featureName.
-         * @return {boolean | Function}
-         */
-        getGeneratorUniqueFunctionFeature(featureName: any): boolean | Function;
-        /**
-         * @private
-         * Find for commit tasks.
-         * @return {boolean | Function}
-         */
-        findGeneratorCustomCommitTask(): boolean | Function;
-        /**
-         * @private
-         * Find for commit tasks.
-         * @return {boolean | Function}
-         */
-        findGeneratorCustomInstallTask(): boolean | Function;
-    };
-    [x: string]: any;
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { default as TerminalAdapter } from './adapter.js';
-export { default as Conflicter } from './util/conflicter.js';
-export { default as createLogger } from './util/log.js';
-export { default } from './environment.js';

package/dist/namespace-composability.d.ts

@@ -1,36 +0,0 @@
-export default composability;
-declare namespace composability {
-    /**
-     * Get a generator only by namespace.
-     * @private
-     * @param  {YeomanNamespace|String} namespace
-     * @return {Generator|null} - the generator found at the location
-     */
-    function getByNamespace(namespace: any): Generator<any, any, any> | null;
-    /**
-     * Lookup and register generators from the custom local repository.
-     *
-     * @private
-     * @param  {YeomanNamespace[]} namespacesToLookup - namespaces to lookup.
-     * @return {Object[]} List of generators
-     */
-    function lookupLocalNamespaces(namespacesToLookup: YeomanNamespace[]): Object[];
-    /**
-     * Search for generators or sub generators by namespace.
-     *
-     * @private
-     * @param {boolean|Object} [options] options passed to lookup. Options singleResult,
-     *                                   filePatterns and packagePatterns can be overridden
-     * @return {Array|Object} List of generators
-     */
-    function lookupNamespaces(namespaces: any, options?: boolean | Object | undefined): Object | any[];
-    /**
-     * Load or install namespaces based on the namespace flag
-     *
-     * @private
-     * @param  {String|Array} - namespaces
-     * @return  {boolean} - true if every required namespace was found.
-     */
-    function prepareEnvironment(namespaces: any): boolean;
-    function createCompose(destinationRoot: any, options?: {}): any;
-}

package/dist/package-manager.d.ts

@@ -1,32 +0,0 @@
-export default packageManagerMixin;
-declare function packageManagerMixin(cls: any): {
-    new (): {
-        [x: string]: any;
-        /**
-         * @private
-         * Get the destination package.json file.
-         * @return {Vinyl | undefined} a Vinyl file.
-         */
-        getDestinationPackageJson(): Vinyl | undefined;
-        /**
-         * @private
-         * Get the destination package.json commit status.
-         * @return {boolean} package.json commit status.
-         */
-        isDestinationPackageJsonCommitted(): boolean;
-        /**
-         * @private
-         * Detect the package manager based on files or use the passed one.
-         * @return {string} package manager.
-         */
-        detectPackageManager(): string;
-        /**
-         * Executes package manager install.
-         * - checks if package.json was committed.
-         * - uses a preferred package manager or try to detect.
-         * @return {Promise<boolean>} Promise true if the install execution suceeded.
-         */
-        packageManagerInstallTask(): Promise<boolean>;
-    };
-    [x: string]: any;
-};

package/dist/resolver.d.ts

@@ -1,146 +0,0 @@
-export default resolver;
-declare namespace resolver {
-    export { packageLookup };
-    /**
-     * Search for generators and their sub generators.
-     *
-     * A generator is a `:lookup/:name/index.js` file placed inside an npm package.
-     *
-     * Defaults lookups are:
-     *   - ./
-     *   - generators/
-     *   - lib/generators/
-     *
-     * So this index file `node_modules/generator-dummy/lib/generators/yo/index.js` would be
-     * registered as `dummy:yo` generator.
-     *
-     * @param {boolean|Object} [options]
-     * @param {boolean} [options.localOnly = false] - Set true to skip lookups of
-     *                                               globally-installed generators.
-     * @param {string|Array} [options.packagePaths] - Paths to look for generators.
-     * @param {string|Array} [options.npmPaths] - Repository paths to look for generators packages.
-     * @param {string|Array} [options.filePatterns='*\/index.js'] - File pattern to look for.
-     * @param {string|Array} [options.packagePatterns='generator-*'] - Package pattern to look for.
-     * @param {boolean}      [options.singleResult=false] - Set true to stop lookup on the first match.
-     * @param {Number}       [options.globbyDeep] - Deep option to be passed to globby.
-     * @return {Object[]} List of generators
-     */
-    export function lookup(options?: boolean | Object | undefined): Object[];
-    /**
-     * Try registering a Generator to this environment.
-     *
-     * @private
-     *
-     * @param  {String} generatorReference A generator reference, usually a file path.
-     * @param  {String} [packagePath] - Generator's package path.
-     * @param  {String} [namespace] - namespace of the generator.
-     * @return {boolean} true if the generator have been registered.
-     */
-    export function _tryRegistering(generatorReference: string, packagePath?: string | undefined, namespace?: string | undefined): boolean;
-    /**
-     * Get the npm lookup directories (`node_modules/`)
-     *
-     * @deprecated
-     *
-     * @param {boolean|Object} [options]
-     * @param {boolean} [options.localOnly = false] - Set true to skip lookups of
-     *                                               globally-installed generators.
-     * @param {boolean} [options.filterPaths = false] - Remove paths that don't ends
-     *                       with a supported path (don't touch at NODE_PATH paths).
-     * @return {Array} lookup paths
-     */
-    export function getNpmPaths(options?: boolean | Object | undefined): any[];
-    /**
-     * Get or create 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`.
-     *
-     * Given a single argument, this method acts as a getter. When both name and
-     * value are provided, acts as a setter and registers that new alias.
-     *
-     * If multiple alias 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().
-     *
-     * @param {String|RegExp} match
-     * @param {String} value
-     *
-     * @example
-     *
-     *     env.alias(/^([a-zA-Z0-9:\*]+)$/, 'generator-$1');
-     *     env.alias(/^([^:]+)$/, '$1:app');
-     *     env.alias(/^([^:]+)$/, '$1:all');
-     *     env.alias('foo');
-     *     // => generator-foo:all
-     */
-    export function alias(match: string | RegExp, value: string): any;
-}
-declare namespace packageLookup {
-    /**
-     * Search for npm packages.
-     *
-     * @private
-     * @method
-     *
-     * @param {boolean|Object} [options]
-     * @param {boolean} [options.localOnly = false] - Set true to skip lookups of
-     *                                               globally-installed generators.
-     * @param {string|Array} [options.packagePaths] - Paths to look for generators.
-     * @param {string|Array} [options.npmPaths] - Repository paths to look for generators packages.
-     * @param {string|Array} [options.filePatterns='*\/index.js'] - File pattern to look for.
-     * @param {string|Array} [options.packagePatterns='lookup'] - Package pattern to look for.
-     * @param {boolean} [options.reverse = false] - Set true reverse npmPaths/packagePaths order
-     * @param {function}     [find]  Executed for each match, return true to stop lookup.
-     */
-    function sync(options?: boolean | Object | undefined, find?: Function | undefined): {
-        filePath: import("@nodelib/fs.scandir").Entry;
-        packagePath: any;
-    }[];
-    /**
-     * Search npm for every available generators.
-     * Generators are npm packages who's name start with `generator-` and who're placed in the
-     * top level `node_module` path. They can be installed globally or locally.
-     *
-     * @method
-     * @private
-     *
-     * @param {String[]} searchPaths List of search paths
-     * @param {String[]} packagePatterns Pattern of the packages
-     * @param {Object}  [globbyOptions]
-     * @return {Array} List of the generator modules path
-     */
-    function findPackagesIn(searchPaths: string[], packagePatterns: string[], globbyOptions?: Object | undefined): any[];
-    /**
-     * Get the npm lookup directories (`node_modules/`)
-     *
-     * @method
-     * @private
-     *
-     * @param {boolean|Object} [options]
-     * @param {boolean} [options.localOnly = false] - Set true to skip lookups of
-     *                                               globally-installed generators.
-     * @param {boolean} [options.filterPaths = false] - Remove paths that don't ends
-     *                       with a supported path (don't touch at NODE_PATH paths).
-     * @return {Array} lookup paths
-     */
-    function getNpmPaths(options?: boolean | Object | undefined): any[];
-    /**
-     * Get the local npm lookup directories
-     * @private
-     * @return {Array} lookup paths
-     */
-    function _getLocalNpmPaths(): any[];
-    /**
-     * Get the global npm lookup directories
-     * Reference: https://nodejs.org/api/modules.html
-     * @private
-     * @return {Array} lookup paths
-     */
-    function _getGlobalNpmPaths(filterPaths?: boolean): any[];
-}

package/dist/spawn-command.d.ts

@@ -1,21 +0,0 @@
-export default spawnCommand;
-declare namespace spawnCommand {
-    /**
-     * Normalize a command across OS and spawn it (asynchronously).
-     *
-     * @param {String} command program to execute
-     * @param {Array} args list of arguments to pass to the program
-     * @param {object} [opt] any execa options
-     * @return {String} spawned process reference
-     */
-    function spawnCommand(command: string, args: any[], opt?: object | undefined): string;
-    /**
-     * Normalize a command across OS and spawn it (synchronously).
-     *
-     * @param {String} command program to execute
-     * @param {Array} args list of arguments to pass to the program
-     * @param {object} [opt] any execa options
-     * @return {String} spawn.sync result
-     */
-    function spawnCommandSync(command: string, args: any[], opt?: object | undefined): string;
-}

package/dist/store.d.ts

@@ -1,66 +0,0 @@
-export default Store;
-/**
- * The Generator store
- * This is used to store generator (npm packages) reference and instantiate them when
- * requested.
- * @constructor
- * @private
- */
-declare class Store {
-    _meta: {};
-    _packagesPaths: {};
-    _packagesNS: any[];
-    /**
-     * Store a module under the namespace key
-     * @param {String}          namespace  - The key under which the generator can be retrieved
-     * @param {String|Function} generator  - A generator module or a module path
-     * @param {String}         packagePath - PackagePath to the generator npm package (optional)
-     * @param {String}          [resolved] - The file path to the generator (used only if generator is a module)
-     */
-    add(namespace: string, generator: string | Function, resolved?: string | undefined, packagePath: string): void;
-    _storeAsPath(namespace: any, resolvedPath: any, packagePath: any): void;
-    _storeAsModule(namespace: any, Generator: any, resolved: any, packagePath: any): void;
-    /**
-     * Get the module registered under the given namespace
-     * @param  {String} namespace
-     * @return {Module}
-     */
-    get(namespace: string): Module;
-    /**
-     * Get the module registered under the given namespace
-     * @param  {String} namespace
-     * @return {Module}
-     */
-    getMeta(namespace: string): Module;
-    /**
-     * Returns the list of registered namespace.
-     * @return {Array} Namespaces array
-     */
-    namespaces(): any[];
-    /**
-     * Get the stored generators meta data
-     * @return {Object} Generators metadata
-     */
-    getGeneratorsMeta(): Object;
-    /**
-     * Store a package under the namespace key
-     * @param {String}     packageNS - The key under which the generator can be retrieved
-     * @param {String}   packagePath - The package path
-     */
-    addPackage(packageNS: string, packagePath: string): void;
-    /**
-     * Get the stored packages namespaces with paths.
-     * @return {Object} Stored packages namespaces with paths.
-     */
-    getPackagesPaths(): Object;
-    /**
-     * Store a package ns
-     * @param {String} packageNS - The key under which the generator can be retrieved
-     */
-    addPackageNS(packageNS: string): void;
-    /**
-     * Get the stored packages namespaces.
-     * @return {Array} Stored packages namespaces.
-     */
-    getPackagesNS(): any[];
-}

package/dist/util/binary-diff.d.ts

@@ -1,2 +0,0 @@
-export function isBinary(filePath: any, newFileContents: any): any;
-export function binaryDiff(existingFilePath: any, newFileContents: any): any;

package/dist/util/command.d.ts

@@ -1,31 +0,0 @@
-declare const YeomanCommand_base: import("commander").CommandConstructor;
-export default class YeomanCommand extends YeomanCommand_base {
-    createCommand(name: any): YeomanCommand;
-    /**
-     * Override addOption to register a negative alternative for every option.
-     * @param {Option} option
-     * @return {YeomanCommand} this;
-     */
-    addOption(option: Option): YeomanCommand;
-    /**
-     * Register arguments using generator._arguments structure.
-     * @param {object[]} generatorArgs
-     * @return {YeomanCommand} this;
-     */
-    addGeneratorArguments(generatorArgs?: object[]): YeomanCommand;
-    /**
-     * Register options using generator._options structure.
-     * @param {object} options
-     * @param {string} blueprintOptionDescription - description of the blueprint that adds the option
-     * @return {YeomanCommand} this;
-     */
-    addGeneratorOptions(options: object): YeomanCommand;
-    _addGeneratorOption(optionName: any, optionDefinition: any, additionalDescription?: string): any;
-    /**
-     * Override to reject errors instead of throwing and add command to error.
-     * @return promise this
-     */
-    parseAsync(argv: any, parseOptions: any): Promise<YeomanCommand>;
-}
-import { Option } from 'commander';
-export {};

package/dist/util/conflicter.d.ts

@@ -1,76 +0,0 @@
-export default Conflicter;
-/**
- * The Conflicter is a module that can be used to detect conflict between files. Each
- * Generator file system helpers pass files through this module to make sure they don't
- * break a user file.
- *
- * When a potential conflict is detected, we prompt the user and ask them for
- * confirmation before proceeding with the actual write.
- *
- * @constructor
- * @property {Boolean} force - same as the constructor argument
- *
- * @param  {TerminalAdapter} adapter - The generator adapter
- * @param  {Object} options - Conflicter options
- * @param  {Boolean} [options.force=false] - When set to true, we won't check for conflict. (the conflicter become a passthrough)
- * @param  {Boolean} [options.bail=false] - When set to true, we will abort on first conflict. (used for testing reproducibility)
- * @param  {Boolean} [options.ignoreWhitespace=false] - When set to true, whitespace changes should not generate a conflict.
- * @param  {Boolean} [options.regenerate=false] - When set to true, identical files should be written to disc.
- * @param  {Boolean} [options.dryRun=false] - When set to true, no write operation will be executed.
- * @param  {Boolean} [options.cwd=process.cwd()] - Path to be used as reference for relative path.
- * @param  {string} cwd - Set cwd for relative logs.
- */
-declare class Conflicter {
-    constructor(adapter: any, options?: {});
-    adapter: any;
-    force: any;
-    bail: any;
-    ignoreWhitespace: any;
-    regenerate: any;
-    dryRun: any;
-    cwd: string;
-    diffOptions: any;
-    queue: any;
-    log(file: any): void;
-    _log(logStatus: any, ...args: any[]): void;
-    /**
-     * Print the file differences to console
-     *
-     * @param  {Object}   file File object respecting this interface: { path, contents }
-     */
-    _printDiff(file: Object, queue?: boolean): Promise<void>;
-    /**
-     * Detect conflicts between file contents at `filepath` with the `contents` passed to the
-     * function
-     *
-     * If `filepath` points to a folder, we'll always return true.
-     *
-     * Based on detect-conflict module
-     *
-     * @param  {import('vinyl')} file File object respecting this interface: { path, contents }
-     * @return {Boolean} `true` if there's a conflict, `false` otherwise.
-     */
-    _detectConflict(file: import('vinyl')): boolean;
-    /**
-     * Check if a file conflict with the current version on the user disk
-     *
-     * A basic check is done to see if the file exists, if it does:
-     *
-     *   1. Read its content from  `fs`
-     *   2. Compare it with the provided content
-     *   3. If identical, mark it as is and skip the check
-     *   4. If diverged, prepare and show up the file collision menu
-     *
-     * @param {import('vinyl')} file - Vinyl file
-     * @param {Object} [conflicterStatus] - Conflicter status
-     * @return  {Promise<Vinyl>} Promise the Vinyl file
-     */
-    checkForCollision(file: import('vinyl'), conflicterStatus?: Object | undefined): Promise<Vinyl>;
-    /**
-     * Actual prompting logic
-     * @private
-     * @param {import('vinyl')} file vinyl file object
-     * @param {Number} counter prompts
-     */
-    private _ask;
-}

package/dist/util/esm.d.ts

@@ -1 +0,0 @@
-export function requireOrImport(fileToImport: any): any;

package/dist/util/log.d.ts

@@ -1,12 +0,0 @@
-export default log;
-declare function log(parameters: any): {
-    (message: any, ctx: any, ...args: any[]): any;
-    write(...args: any[]): any;
-    writeln(...args: any[]): any;
-    ok(...args: any[]): any;
-    error(...args: any[]): any;
-    table(options: any): string;
-};
-declare namespace log {
-    export { npmlog as tracker };
-}

package/dist/util/namespace.d.ts

@@ -1,80 +0,0 @@
-/**
- * Parse a namespace
- *
- * @private
- * @param  {String} namespace
- * @return {Object} parsed
- * @return {String} parsed.complete - Complete namespace
- * @return {String} parsed.namespace - Namespace with format @scope/namespace:generator
- * @return {String} parsed.generatorHint - Package name
- * @return {String} parsed.id - Id of the instance.
- * @return {String} parsed.instanceId - Instance id with format @scope/namespace:generator#id
- * @return {String} parsed.method - Method id with format @scope/namespace:generator+foo+bar
- * @return {String} parsed.scope - Scope name
- * @return {String} parsed.packageNamespace - Package namespace with format @scope/namespace
- * @return {String} parsed.generator - Original namespace
- * @return {String} parsed.flags - Original namespace
- */
-export function parseNamespace(complete: any): Object;
-/**
- * Convert a namespace to a namespace object
- *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function toNamespace(namespace: string | YeomanNamespace): YeomanNamespace;
-/**
- * Convert a package name to a namespace object
- *
- * @private
- * @param  {String} packageName
- * @return {YeomanNamespace}
- */
-export function namespaceFromPackageName(packageName: string): YeomanNamespace;
-/**
- * Convert a namespace to a namespace object
- *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function requireNamespace(namespace: string | YeomanNamespace): YeomanNamespace;
-/**
- * Test if the object is an Namespace instance.
- *
- * @private
- * @param  {Object} namespace
- * @return {Boolean} True if namespace is a YeomanNamespace
- */
-export function isNamespace(namespace: Object): boolean;
-export class YeomanNamespace {
-    static parse(complete: any): {
-        complete: any;
-    } | null;
-    constructor(parsed: any);
-    _original: any;
-    scope: any;
-    unscoped: any;
-    generator: any;
-    instanceId: any;
-    semver: any;
-    methods: any;
-    flags: any;
-    _update(parsed: any): void;
-    command: any;
-    get _scopeAddition(): string;
-    get generatorName(): string;
-    _semverAddition(post: any): any;
-    get instanceName(): string;
-    get complete(): string;
-    get packageNamespace(): string;
-    set namespace(arg: string);
-    get namespace(): string;
-    get unscopedNamespace(): string;
-    get id(): string;
-    get generatorHint(): string;
-    get versionedHint(): string;
-    with(newValues: any): YeomanNamespace;
-    toString(): string;
-}

package/dist/util/repository.d.ts

@@ -1,116 +0,0 @@
-export default YeomanRepository;
-/**
- * @private
- */
-declare class YeomanRepository {
-    constructor({ repositoryPath, arboristRegistry }?: {
-        repositoryPath?: string | undefined;
-        arboristRegistry: any;
-    });
-    log: {
-        (message: any, ctx: any, ...args: any[]): any;
-        write(...args: any[]): any;
-        writeln(...args: any[]): any;
-        ok(...args: any[]): any;
-        error(...args: any[]): any;
-        table(options: any): string;
-    };
-    tracker: any;
-    private set repositoryPath(arg);
-    /**
-     * @private
-     * @property
-     * Repository absolute path (npm --prefix).
-     */
-    private get repositoryPath();
-    arboristRegistry: any;
-    _repositoryPath: any;
-    _nodeModulesPath: string | undefined;
-    /**
-     * @private
-     * @property nodeModulesPath
-     * Path to the repository's node_modules.
-     */
-    private get nodeModulesPath();
-    /**
-     * @private
-     * @method
-     * Create the repositoryPath if it doesn't exists.
-     */
-    private createRepositoryFolder;
-    /**
-     * @private
-     * @method
-     * Resolve the package name module path inside the [repository path]{@link repository.repositoryPath}
-     * @param {String} packageName - Package name. If packageName is a absolute path then modulePath is joined to it.
-     * @param {String} [modulePath] - Path to a module inside the package path.
-     * @returns {String} Absolute module path.
-     */
-    private resolvePackagePath;
-    /**
-     * @private
-     * @method
-     * Remove the package from node's cache, necessary for a reinstallation.
-     * Removes only package.json by default, it's used to version verification.
-     * Removes only cache of the repository's packages.
-     * @param {String} packageName - Package name.
-     * @param {Boolean} [force=false] - If true removes every cache the package.
-     * @throw Error if force === false and any file other the package.json is loaded.
-     */
-    private cleanupPackageCache;
-    /**
-     * @private
-     * @param {Object} options - options to be passed to arborist reify eg: {add: { dependencies: [ pkgSpec ] }, rm: [ pkgName ]}
-     */
-    private reifyRepository;
-    arb: any;
-    /**
-     * @private
-     * @method
-     * Verify if the package is installed and matches the version range.
-     * @param {String} packageName - Package name.
-     * @param {String} versionRange - Version range of the package.
-     * @returns {Boolean} True if the package is installed and matches the version.
-     * @throws Error.
-     */
-    private verifyInstalledVersion;
-    /**
-     * @private
-     * @method
-     * Install a package into the repository.
-     * @param {String} packageName - Package name.
-     * @param {String} versionRange - range Version of the package.
-     * @returns {String} Package path.
-     * @throws Error.
-     */
-    private installPackage;
-    /**
-     * @private
-     * @method
-     * Install packages.
-     * @param {Object} packages - Packages to be installed.
-     * @returns {Boolean}
-     * @example
-     * repository.installPackages({ 'yeoman-environment': '2.3.0' });
-     */
-    private installPackages;
-    /**
-     * @private
-     * @method
-     * Get the installed package version.
-     * @param {String} packageName - Package name.
-     * @returns {String|undefined} Package version or undefined.
-     */
-    private getPackageVersion;
-    /**
-     * @private
-     * @method
-     * Require a module from the repository.
-     * @param {String} packageName - Package name.
-     * @param {String} versionRange - Version range of the package.
-     * @param {String} modulePath - Package name.
-     * @returns {Object} Module.
-     * @throws Error.
-     */
-    private requireModule;
-}

package/dist/util/transform.d.ts

@@ -1,55 +0,0 @@
-export function parseYoAttributesFile(yoAttributeFileName: any): {
-    [k: string]: string;
-};
-/**
- * Transform api should be avoided by generators without a executable.
- * May break between major yo versions.
- */
-export function createConflicterCheckTransform(conflicter: any, conflicterStatus: any): import("p-transform").default;
-/**
- * @private
- */
-export function getConflicterStatusForFile(conflicter: any, filePath: any, yoAttributeFileName?: string): undefined;
-/**
- * Transform api should be avoided by generators without a executable.
- * May break between major yo versions.
- *
- * Create a yo-resolve transform stream.
- * Suports pre-defined conflicter actions action based on file glob.
- * @param {Conflicter} conflicter - Conflicter instance
- * @param {string} yoResolveFileName - .yo-resolve filename
- * @return {Transform} A Transform https://nodejs.org/api/stream.html#stream_class_stream_transform
- */
-export function createYoResolveTransform(conflicter: Conflicter, yoResolveFileName: string): Transform;
-/**
- * Transform api should be avoided by generators without a executable.
- * May break between major yo versions.
- *
- * Create a force yeoman configs transform stream.
- * @return {Transform} A Transform https://nodejs.org/api/stream.html#stream_class_stream_transform
- */
-export function createYoRcTransform(): Transform;
-/**
- * Transform api should be avoided by generators without a executable.
- * May break between major yo versions.
- *
- * Create a transform to apply conflicter status.
- * @param {Log} logger - Log reference. See log.js
- * @return {Transform} A Transform https://nodejs.org/api/stream.html#stream_class_stream_transform
- */
-export function createConflicterStatusTransform(): Transform;
-/**
- * Conditional filter on pattern.
- *
- * @param {String} pattern - Minimatch pattern.
- * @param {Object} options - Minimatch options.
- */
-export function patternFilter(pattern: string, options: Object): import("p-transform").default;
-/**
- * Conditional spy on pattern.
- *
- * @param {Function} spy.
- * @param {String} pattern - Minimatch pattern.
- * @param {Object} options - Minimatch options.
- */
-export function patternSpy(spy: any, pattern: string, options: Object): import("p-transform").default;

package/dist/util/util.d.ts

@@ -1,14 +0,0 @@
-export { default as log } from "./log.js";
-/**
- * Create a "sloppy" copy of an initial Environment object. The focus of this method is on
- * performance rather than correctly deep copying every property or recreating a correct
- * instance. Use carefully and don't rely on `hasOwnProperty` of the copied environment.
- *
- * Every property are shared except the runLoop which is regenerated.
- *
- * @param {Environment} initialEnv - an Environment instance
- * @return {Environment} sloppy copy of the initial Environment
- */
-export function duplicateEnv(initialEnv: Environment): Environment;
-export function execaOutput(cmg: any, args: any, options: any): string | undefined;
-import Environment from '../environment.js';