Generator Discovery

/**
 * Look up specific generator by namespace with path resolution
 * @param namespace - Generator namespace to search for
 * @param options - Lookup options including path resolution flags
 * @returns Generator path(s) or empty if not found
 */
function lookupGenerator(
  namespace: string,
  options?: ModuleLookupOptions & {
    packagePath?: boolean;
    generatorPath?: boolean;
  }
): string | string[];

import { lookupGenerator } from "yeoman-environment";

// Find generator by namespace
const generatorPath = lookupGenerator("angular:component");

// Get package path instead of generator path
const packagePath = lookupGenerator("angular:component", { 
  packagePath: true 
});

// Get both paths
const paths = lookupGenerator("angular:component", { 
  packagePath: true,
  generatorPath: true 
});

/**
 * Search for generators with filtering and registration options
 * This method is available on Environment and EnvironmentBase instances
 * @param options - Lookup configuration options
 * @returns Array of found generator metadata
 */
lookup(options?: EnvironmentLookupOptions): Promise<LookupGeneratorMeta[]>;

import { createEnv } from "yeoman-environment";

const env = createEnv();

// Search for all generators
const allGenerators = await env.lookup();

// Search only local generators
const localGenerators = await env.lookup({ localOnly: true });

// Search with custom namespace processing
const scopedGenerators = await env.lookup({
  registerToScope: "myapp",
  customizeNamespace: (ns) => ns?.startsWith("@myorg/") ? ns : undefined
});

// Search specific package patterns
const angularGenerators = await env.lookup({
  packagePatterns: ["generator-angular*"],
  filePatterns: ["generators/*/index.js"]
});

/**
 * Lookup and register local packages
 * Available on Environment instances
 * @param packagesToLookup - Optional array of specific packages to lookup
 */
lookupLocalPackages(packagesToLookup?: string[]): Promise<void>;

import { createEnv } from "yeoman-environment";

const env = createEnv();

// Lookup all local packages
await env.lookupLocalPackages();

// Lookup specific packages
await env.lookupLocalPackages([
  "generator-webapp",
  "generator-node"
]);

interface LookupOptions extends LookupOptionsApi {
  /** Lookup paths for generators (defaults: ['.', 'generators', 'lib/generators', 'dist/generators']) */
  lookups?: string[];
  /** Skip lookups of globally-installed generators */
  localOnly?: boolean;
  /** Specific paths to look for generators */
  packagePaths?: string | string[];
  /** Repository paths to look for generator packages */
  npmPaths?: string | string[];
  /** File patterns to match (e.g., '*/index.js', 'generators/*/index.ts') */
  filePatterns?: string | string[];
  /** Package patterns to match (e.g., 'generator-*', '@angular/schematics-*') */
  packagePatterns?: string | string[];
  /** Stop lookup on first match */
  singleResult?: boolean;
  /** Depth option for globby searches */
  globbyDeep?: number;
  /** Filter discovered paths */
  filterPaths?: boolean;
  /** Reverse results (affects override behavior) */
  reverse?: boolean;
}

interface EnvironmentLookupOptions extends LookupOptions {
  /** Add scope to namespace if missing */
  registerToScope?: string;
  /** Customize namespace during registration */
  customizeNamespace?: (ns?: string) => string | undefined;
}

interface ModuleLookupOptions {
  /** Skip lookups of globally-installed generators */
  localOnly?: boolean;
  /** Specific paths to search */
  packagePaths?: string | string[];
  /** npm paths to search */
  npmPaths?: string | string[];
  /** Package patterns to match */
  packagePatterns?: string | string[];
  /** Stop on first result */
  singleResult?: boolean;
  /** Additional lookup options */
  [key: string]: any;
}

interface LookupGeneratorMeta extends BaseGeneratorMeta {
  /** Full file path to the generator */
  filePath: string;
  /** Path to the package containing the generator */
  packagePath: string;
  /** Lookup paths used to find this generator */
  lookups: string[];
}

interface BaseGeneratorMeta {
  /** Generator namespace (e.g., 'angular:component') */
  namespace: string;
  /** Resolved path to generator file */
  resolved?: string;
  /** Path to package containing generator */
  packagePath?: string;
}

interface GeneratorMeta extends BaseGeneratorMeta {
  /** Create generator instance with arguments */
  instantiate(...args: any[]): Promise<BaseGenerator>;
  /** Create generator instance for help display */
  instantiateHelp(): Promise<BaseGenerator>;
}

// Find all React-related generators
const reactGenerators = await env.lookup({
  packagePatterns: ["*react*", "generator-*react*"],
  customizeNamespace: (ns) => ns?.includes("react") ? ns : undefined
});

// Search only TypeScript generators
const tsGenerators = await env.lookup({
  filePatterns: ["generators/*/index.ts", "*/index.ts"],
  packagePatterns: ["generator-*"]
});

// Fast single-result lookup
const firstMatch = await env.lookup({
  packagePatterns: ["generator-webapp"],
  singleResult: true
});