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

package/dist/environment-full.d.ts

@@ -0,0 +1,115 @@
+import { type LookupOptions } from './generator-lookup.js';
+import EnvironmentBase, { type EnvironmentOptions } from './environment-base.js';
+declare class FullEnvironment extends EnvironmentBase {
+    constructor(options?: EnvironmentOptions);
+    /**
+     * Load options passed to the Generator that should be used by the Environment.
+     *
+     * @param {Object} options
+     */
+    loadEnvironmentOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "skipInstall" | "nodePackageManager">;
+    /**
+     * Load options passed to the Environment that should be forwarded to the Generator.
+     *
+     * @param {Object} options
+     */
+    loadSharedOptions(options: EnvironmentOptions): Pick<EnvironmentOptions, "skipInstall" | "forceInstall" | "skipCache" | "skipLocalCache" | "skipParseOptions" | "localConfigOnly" | "askAnswered">;
+    /**
+     * @protected
+     * 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;
+    /**
+     * @protected
+     * Returns the list of registered namespace.
+     * @return {Array}
+     */
+    namespaces(): string[];
+    /**
+     * @protected
+     * Returns stored generators meta
+     * @return {Object}
+     */
+    getGeneratorsMeta(): Record<string, import("@yeoman/types").GeneratorMeta>;
+    /**
+     * @protected
+     * Get registered generators names
+     *
+     * @return {Array}
+     */
+    getGeneratorNames(): (string | undefined)[];
+    /**
+     * Get last added path for a namespace
+     *
+     * @param  {String} - namespace
+     * @return {String} - path of the package
+     */
+    getPackagePath(namespace: string): string | undefined;
+    /**
+     * Get paths for a namespace
+     *
+     * @param - namespace
+     * @return array of paths.
+     */
+    getPackagePaths(namespace: string): string[];
+    /**
+     * Generate a command for the generator and execute.
+     *
+     * @param {string} generatorNamespace
+     * @param {string[]} args
+     */
+    execute(generatorNamespace: string, args?: never[]): Promise<void>;
+    requireGenerator(namespace: string): 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.
+     */
+    installLocalGenerators(packages: Record<string, string | undefined>): Promise<boolean>;
+    /**
+     * Lookup and register generators from the custom local repository.
+     *
+     * @param  {String[]} [packagesToLookup='generator-*'] - packages to lookup.
+     */
+    lookupLocalPackages(packagesToLookup?: string[]): Promise<void>;
+    /**
+     * Lookup and register generators from the custom local repository.
+     *
+     * @private
+     * @param  {YeomanNamespace[]} namespacesToLookup - namespaces to lookup.
+     * @return {Promise<Object[]>} List of generators
+     */
+    lookupLocalNamespaces(namespacesToLookup: string | string[]): Promise<void | never[]>;
+    /**
+     * 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
+     */
+    lookupNamespaces(namespaces: string | string[], options?: LookupOptions): Promise<import("@yeoman/types").LookupGeneratorMeta[][]>;
+    /**
+     * Load or install namespaces based on the namespace flag
+     *
+     * @private
+     * @param  {String|Array} - namespaces
+     * @return  {boolean} - true if every required namespace was found.
+     */
+    prepareEnvironment(namespaces: string | string[]): Promise<boolean>;
+    /**
+     * 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[], options?: any): Promise<void>;
+}
+export default FullEnvironment;

package/dist/environment-full.js

@@ -0,0 +1,321 @@
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { requireNamespace, toNamespace } from '@yeoman/namespace';
+import { flyImport } from 'fly-import';
+import { defaults, pick, uniq } from 'lodash-es';
+import semver from 'semver';
+import YeomanCommand from './util/command.js';
+import EnvironmentBase from './environment-base.js';
+import { splitArgsFromString } from './util/util.js';
+class FullEnvironment extends EnvironmentBase {
+    constructor(options = {}, adapterCompat) {
+        if (adapterCompat) {
+            options.adapter = adapterCompat;
+        }
+        super(options);
+        this.loadSharedOptions(this.options);
+        if (this.sharedOptions.skipLocalCache === undefined) {
+            this.sharedOptions.skipLocalCache = true;
+        }
+    }
+    /**
+     * Load options passed to the Generator that should be used by the Environment.
+     *
+     * @param {Object} options
+     */
+    loadEnvironmentOptions(options) {
+        const environmentOptions = pick(options, ['skipInstall', 'nodePackageManager']);
+        defaults(this.options, environmentOptions);
+        return environmentOptions;
+    }
+    /**
+     * Load options passed to the Environment that should be forwarded to the Generator.
+     *
+     * @param {Object} options
+     */
+    loadSharedOptions(options) {
+        const optionsToShare = pick(options, [
+            'skipInstall',
+            'forceInstall',
+            'skipCache',
+            'skipLocalCache',
+            'skipParseOptions',
+            'localConfigOnly',
+            'askAnswered',
+        ]);
+        Object.assign(this.sharedOptions, optionsToShare);
+        return optionsToShare;
+    }
+    /**
+     * @protected
+     * 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 = 'init') {
+        const out = [
+            'Usage: :binary: GENERATOR [args] [options]',
+            '',
+            'General options:',
+            "  --help       # Print generator's options and usage",
+            '  -f, --force  # Overwrite files that already exist',
+            '',
+            'Please choose a generator below.',
+            '',
+        ];
+        const ns = this.namespaces();
+        const groups = {};
+        for (const namespace of ns) {
+            const base = namespace.split(':')[0];
+            if (!groups[base]) {
+                groups[base] = [];
+            }
+            groups[base].push(namespace);
+        }
+        for (const key of Object.keys(groups).sort()) {
+            const group = groups[key];
+            if (group.length > 0) {
+                out.push('', key.charAt(0).toUpperCase() + key.slice(1));
+            }
+            for (const ns of groups[key]) {
+                out.push(`  ${ns}`);
+            }
+        }
+        return out.join('\n').replace(/:binary:/g, name);
+    }
+    /**
+     * @protected
+     * Returns the list of registered namespace.
+     * @return {Array}
+     */
+    namespaces() {
+        return this.store.namespaces();
+    }
+    /**
+     * @protected
+     * Returns stored generators meta
+     * @return {Object}
+     */
+    getGeneratorsMeta() {
+        return this.store.getGeneratorsMeta();
+    }
+    /**
+     * @protected
+     * Get registered generators names
+     *
+     * @return {Array}
+     */
+    getGeneratorNames() {
+        return uniq(Object.keys(this.getGeneratorsMeta()).map(namespace => toNamespace(namespace)?.packageNamespace));
+    }
+    /**
+     * Get last added path for a namespace
+     *
+     * @param  {String} - namespace
+     * @return {String} - path of the package
+     */
+    getPackagePath(namespace) {
+        if (namespace.includes(':')) {
+            const generator = this.getGeneratorMeta(namespace);
+            return generator?.packagePath;
+        }
+        const packagePaths = this.getPackagePaths(namespace) || [];
+        return packagePaths[0];
+    }
+    /**
+     * Get paths for a namespace
+     *
+     * @param - namespace
+     * @return array of paths.
+     */
+    getPackagePaths(namespace) {
+        return (this.store.getPackagesPaths()[namespace] || this.store.getPackagesPaths()[requireNamespace(this.alias(namespace)).packageNamespace]);
+    }
+    /**
+     * Generate a command for the generator and execute.
+     *
+     * @param {string} generatorNamespace
+     * @param {string[]} args
+     */
+    async execute(generatorNamespace, args = []) {
+        const namespace = requireNamespace(generatorNamespace);
+        if (!(await this.get(namespace.namespace))) {
+            await this.lookup({
+                packagePatterns: [namespace.generatorHint],
+                singleResult: true,
+            });
+        }
+        if (!(await this.get(namespace.namespace))) {
+            await this.installLocalGenerators({
+                [namespace.generatorHint]: namespace.semver,
+            });
+        }
+        const namespaceCommand = this.command ? this.command.command(namespace.namespace) : new YeomanCommand();
+        namespaceCommand.usage('[generator-options]');
+        // Instantiate the generator for options
+        const generator = await this.create(namespace.namespace, { generatorArgs: [], generatorOptions: { help: true } });
+        namespaceCommand.registerGenerator(generator);
+        namespaceCommand._parseCommand([], args);
+        return this.run([namespace.namespace, ...namespaceCommand.args], {
+            ...namespaceCommand.opts(),
+        });
+    }
+    async requireGenerator(namespace) {
+        if (namespace === undefined) {
+            try {
+                // @ts-expect-error yeoman-generator type maybe missing
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                const { default: Generator } = await import('yeoman-generator');
+                return Generator;
+            }
+            catch { }
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const { default: Generator } = await flyImport('yeoman-generator');
+            return Generator;
+        }
+        // Namespace is a version
+        if (semver.valid(namespace)) {
+            // Create a hash to install any version range in the local repository
+            const hash = createHash('shake256', { outputLength: 2 }).update(namespace, 'utf8').digest('hex');
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const { default: Generator } = await flyImport(`@yeoman/generator-impl-${hash}@npm:yeoman-generator@${namespace}`);
+            return Generator;
+        }
+        return this.get(namespace);
+    }
+    /**
+     * 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.
+     */
+    async installLocalGenerators(packages) {
+        const entries = Object.entries(packages);
+        const specs = entries.map(([packageName, version]) => `${packageName}${version ? `@${version}` : ''}`);
+        const installResult = await this.repository.install(specs);
+        const failToInstall = installResult.find(result => !result.path);
+        if (failToInstall) {
+            throw new Error(`Fail to install ${failToInstall.pkgid}`);
+        }
+        await this.lookup({ packagePaths: installResult.map(result => result.path) });
+        return true;
+    }
+    /**
+     * Lookup and register generators from the custom local repository.
+     *
+     * @param  {String[]} [packagesToLookup='generator-*'] - packages to lookup.
+     */
+    async lookupLocalPackages(packagesToLookup = ['generator-*']) {
+        await this.lookup({
+            packagePatterns: packagesToLookup,
+            npmPaths: [join(this.repository.repositoryPath, 'node_modules')],
+        });
+    }
+    /**
+     * Lookup and register generators from the custom local repository.
+     *
+     * @private
+     * @param  {YeomanNamespace[]} namespacesToLookup - namespaces to lookup.
+     * @return {Promise<Object[]>} List of generators
+     */
+    async lookupLocalNamespaces(namespacesToLookup) {
+        if (!namespacesToLookup) {
+            return [];
+        }
+        namespacesToLookup = Array.isArray(namespacesToLookup) ? namespacesToLookup : [namespacesToLookup];
+        const namespaces = namespacesToLookup.map(ns => requireNamespace(ns));
+        // Keep only those packages that has a compatible version.
+        return this.lookupLocalPackages(namespaces.map(ns => ns.generatorHint));
+    }
+    /**
+     * 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
+     */
+    async lookupNamespaces(namespaces, options = {}) {
+        if (!namespaces) {
+            return [];
+        }
+        namespaces = Array.isArray(namespaces) ? namespaces : [namespaces];
+        const namespacesObjs = namespaces.map(ns => requireNamespace(ns));
+        const options_ = namespacesObjs.map(ns => {
+            const nsOptions = { packagePatterns: [ns.generatorHint] };
+            if (ns.generator) {
+                // Build filePatterns to look specifically for the namespace.
+                const genPath = ns.generator.split(':').join('/');
+                let filePatterns = [`${genPath}/index.?s`, `${genPath}.?s`];
+                const lookups = options.lookups ?? this.lookups;
+                filePatterns = lookups.flatMap(prefix => filePatterns.map(pattern => join(prefix, pattern)));
+                nsOptions.filePatterns = filePatterns;
+                nsOptions.singleResult = true;
+            }
+            return nsOptions;
+        });
+        return Promise.all(options_.flatMap(async (opt) => this.lookup({ ...opt, ...options })));
+    }
+    /**
+     * Load or install namespaces based on the namespace flag
+     *
+     * @private
+     * @param  {String|Array} - namespaces
+     * @return  {boolean} - true if every required namespace was found.
+     */
+    async prepareEnvironment(namespaces) {
+        namespaces = Array.isArray(namespaces) ? namespaces : [namespaces];
+        let missing = namespaces.map(ns => requireNamespace(ns));
+        const updateMissing = async () => {
+            const entries = await Promise.all(missing.map(async (ns) => [ns, await this.get(ns)]));
+            missing = entries.filter(([_ns, gen]) => Boolean(gen)).map(([ns]) => ns);
+        };
+        await updateMissing();
+        // Install missing
+        const toInstall = Object.fromEntries(missing.map(ns => [ns.generatorHint, ns.semver]));
+        await this.installLocalGenerators(toInstall);
+        await updateMissing();
+        if (missing.length === 0) {
+            return true;
+        }
+        throw new Error(`Error preparing environment for ${missing.map(ns => ns.complete).join(',')}`);
+    }
+    /**
+     * 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]
+     */
+    async run(args, options) {
+        args = Array.isArray(args) ? args : splitArgsFromString(args);
+        options = { ...options };
+        const name = args.shift();
+        if (!name) {
+            throw new Error('Must provide at least one argument, the generator namespace to invoke.');
+        }
+        this.loadEnvironmentOptions(options);
+        if (this.experimental && !this.getGeneratorMeta(name)) {
+            try {
+                await this.prepareEnvironment(name);
+            }
+            catch { }
+        }
+        const generator = await this.create(name, {
+            generatorArgs: args,
+            generatorOptions: {
+                ...options,
+                initialGenerator: true,
+            },
+        });
+        if (options.help) {
+            console.log(generator.help());
+            return undefined;
+        }
+        return this.runGenerator(generator);
+    }
+}
+export default FullEnvironment;

package/dist/generator-lookup.d.ts

@@ -0,0 +1,56 @@
+import { type LookupOptions as LookupOptionsApi } from '@yeoman/types';
+import { type ModuleLookupOptions } from './module-lookup.js';
+export type LookupOptions = LookupOptionsApi & ModuleLookupOptions & {
+    lookups?: string[];
+};
+type LookupMeta = {
+    filePath: string;
+    packagePath: string;
+    lookups: string[];
+};
+export declare const defaultExtensions: string[];
+/**
+ * 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 {Promise<Object[]>} List of generators
+ */
+export declare function lookupGenerators(options?: LookupOptions, register?: (meta: LookupMeta) => boolean): Promise<{
+    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 & {
+    packagePath?: boolean;
+    generatorPath?: boolean;
+}): string | string[];
+export {};

package/dist/generator-lookup.js

@@ -0,0 +1,97 @@
+import { extname, isAbsolute, join, posix } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { requireNamespace, toNamespace } from '@yeoman/namespace';
+import { moduleLookupSync, getNpmPaths, findPackagesIn } from './module-lookup.js';
+import { asNamespace, defaultLookups } from './util/namespace.js';
+export const defaultExtensions = ['.ts', '.cts', '.mts', '.js', '.cjs', '.mjs'];
+/**
+ * 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 {Promise<Object[]>} List of generators
+ */
+export async function lookupGenerators(options = {}, register) {
+    const { lookups = defaultLookups } = options;
+    options = {
+        // Js generators should be after, last will override registered one.
+        filePatterns: lookups.flatMap(prefix => defaultExtensions.map(ext => `${prefix}/*/index${ext}`)),
+        filterPaths: false,
+        packagePatterns: ['generator-*'],
+        reverse: !options.singleResult,
+        ...options,
+    };
+    return moduleLookupSync(options, ({ packagePath, files }) => {
+        files = [...files].sort((a, b) => {
+            return defaultExtensions.indexOf(extname(a)) - defaultExtensions.indexOf(extname(b));
+        });
+        for (const filePath of files) {
+            const registered = register?.({ filePath, packagePath, lookups });
+            if (options.singleResult && registered) {
+                return filePath;
+            }
+        }
+        return undefined;
+    });
+}
+/**
+ * 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 function lookupGenerator(namespace, options) {
+    options = typeof options === 'boolean' ? { localOnly: options } : options ?? {};
+    options.singleResult = options.singleResult ?? true;
+    options.filePatterns = options.filePatterns ?? defaultLookups.map(prefix => join(prefix, '*/index.{js,ts}'));
+    const ns = requireNamespace(namespace);
+    options.packagePatterns = options.packagePatterns ?? [ns.generatorHint];
+    options.npmPaths = options.npmPaths ?? getNpmPaths({ localOnly: options.localOnly }).reverse();
+    options.packagePatterns = options.packagePatterns ?? ['generator-*'];
+    options.packagePaths = options.packagePaths ?? findPackagesIn(options.npmPaths, options.packagePatterns);
+    let paths = options.singleResult ? undefined : [];
+    moduleLookupSync(options, ({ files, packagePath }) => {
+        for (const filename of files) {
+            const fileNs = asNamespace(filename, { lookups: defaultLookups });
+            const ns = toNamespace(fileNs);
+            if (namespace === fileNs || (options.packagePath && namespace === ns?.packageNamespace)) {
+                // Version 2.6.0 returned pattern instead of modulePath for options.packagePath
+                const returnPath = options.packagePath ? packagePath : options.generatorPath ? posix.join(filename, '../../') : filename;
+                if (options.singleResult) {
+                    paths = returnPath;
+                    return filename;
+                }
+                paths.push(returnPath);
+            }
+        }
+        return undefined;
+    });
+    if (options.singleResult) {
+        const generatorPath = paths;
+        return generatorPath && isAbsolute(generatorPath) ? pathToFileURL(generatorPath).toString() : generatorPath;
+    }
+    return paths.map(gen => (isAbsolute(gen) ? pathToFileURL(gen).toString() : gen));
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { type EnvironmentOptions } from './environment-base.js';
+import Environment from './environment-full.js';
+export { default } from './environment-full.js';
+export { default as EnvironmentBase } from './environment-base.js';
+export declare const createEnv: (options?: EnvironmentOptions) => Environment;
+export * from './commands.js';
+export * from './util/command.js';
+export * from './package-manager.js';
+export * from './commit.js';
+export { lookupGenerator } from './generator-lookup.js';

package/dist/index.js

@@ -1,5 +1,9 @@
-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';
-//# sourceMappingURL=index.js.map
+import Environment from './environment-full.js';
+export { default } from './environment-full.js';
+export { default as EnvironmentBase } from './environment-base.js';
+export const createEnv = (options) => new Environment(options);
+export * from './commands.js';
+export * from './util/command.js';
+export * from './package-manager.js';
+export * from './commit.js';
+export { lookupGenerator } from './generator-lookup.js';

package/dist/module-lookup.d.ts

@@ -0,0 +1,59 @@
+export type ModuleLookupOptions = {
+    /** Set true to skip lookups of globally-installed generators */
+    localOnly?: boolean;
+    /** Paths to look for generators */
+    packagePaths?: string[];
+    /** Repository paths to look for generators packages */
+    npmPaths?: string[];
+    /** File pattern to look for */
+    filePatterns?: string[];
+    /** The package patterns to look for */
+    packagePatterns?: string[];
+    /** A value indicating whether the lookup should be stopped after finding the first result */
+    singleResult?: boolean;
+    filterPaths?: boolean;
+    /** Set true reverse npmPaths/packagePaths order */
+    reverse?: boolean;
+    /** The `deep` option to pass to `globby` */
+    globbyDeep?: number;
+    globbyOptions?: any;
+};
+/**
+ * Search for npm packages.
+ */
+export declare function moduleLookupSync(options: ModuleLookupOptions, find: (arg: {
+    files: string[];
+    packagePath: string;
+}) => string | undefined): {
+    filePath: string;
+    packagePath: string;
+}[];
+/**
+ * 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
+ *
+ * @param searchPaths List of search paths
+ * @param packagePatterns Pattern of the packages
+ * @param globbyOptions
+ * @return List of the generator modules path
+ */
+export declare function findPackagesIn(searchPaths: string[], packagePatterns: string[], globbyOptions?: any): any[];
+/**
+ * Get the npm lookup directories (`node_modules/`)
+ *
+ * @method
+ *
+ * @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 declare function getNpmPaths(options?: {
+    localOnly?: boolean;
+    filterPaths?: boolean;
+}): string[];