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

package/dist/util/command.d.ts

@@ -1,31 +1,34 @@
-declare const YeomanCommand_base: import("commander").CommandConstructor;
-export default class YeomanCommand extends YeomanCommand_base {
-    createCommand(name: any): YeomanCommand;
+import { Command, Option } from 'commander';
+import type BaseEnvironment from '../environment-base.js';
+export default class YeomanCommand extends Command {
+    env?: BaseEnvironment;
+    createCommand(name?: string): YeomanCommand;
     /**
      * Override addOption to register a negative alternative for every option.
      * @param {Option} option
      * @return {YeomanCommand} this;
      */
-    addOption(option: Option): YeomanCommand;
+    addOption(option: Option): this;
+    /**
+     * Load Generator options into a commander instance.
+     *
+     * @param {Generator} generator - Generator
+     * @return {Command} return command
+     */
+    registerGenerator(generator: any): this;
     /**
      * Register arguments using generator._arguments structure.
      * @param {object[]} generatorArgs
      * @return {YeomanCommand} this;
      */
-    addGeneratorArguments(generatorArgs?: object[]): YeomanCommand;
+    addGeneratorArguments(generatorArgs?: any[]): this;
     /**
      * 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>;
+    addGeneratorOptions(options: Record<string, any>): this;
+    _addGeneratorOption(optionName: string, optionDefinition: any, additionalDescription?: string): any;
 }
-import { Option } from 'commander';
-export {};
+export declare const addEnvironmentOptions: (command?: YeomanCommand) => YeomanCommand;

package/dist/util/command.js

@@ -1,5 +1,6 @@
 import { Command, Option } from 'commander';
 export default class YeomanCommand extends Command {
+    env;
     createCommand(name) {
         return new YeomanCommand(name);
     }
@@ -24,13 +25,22 @@ export default class YeomanCommand extends Command {
         }
         return result;
     }
+    /**
+     * Load Generator options into a commander instance.
+     *
+     * @param {Generator} generator - Generator
+     * @return {Command} return command
+     */
+    registerGenerator(generator) {
+        return this.addGeneratorOptions(generator._options).addGeneratorArguments(generator._arguments);
+    }
     /**
      * Register arguments using generator._arguments structure.
      * @param {object[]} generatorArgs
      * @return {YeomanCommand} this;
      */
     addGeneratorArguments(generatorArgs = []) {
-        if (!generatorArgs) {
+        if (!generatorArgs || generatorArgs.length === 0) {
             return this;
         }
         const args = generatorArgs
@@ -75,23 +85,28 @@ export default class YeomanCommand extends Command {
         else if (optionDefinition.type === Array) {
             cmdString = optionDefinition.required === false ? `${cmdString} [value...]` : `${cmdString} <value...>`;
         }
-        return this.addOption(new Option(cmdString, optionDefinition.description + additionalDescription)
+        return this.addOption(new Option(cmdString, `${optionDefinition.description}${additionalDescription}`)
             .default(optionDefinition.default)
             .hideHelp(optionDefinition.hide));
     }
-    /**
-     * Override to reject errors instead of throwing and add command to error.
-     * @return promise this
-     */
-    parseAsync(argv, parseOptions) {
-        try {
-            this.parse(argv, parseOptions);
-        }
-        catch (commanderError) {
-            commanderError.command = this;
-            return Promise.reject(commanderError);
-        }
-        return Promise.all(this._actionResults).then(() => this);
-    }
 }
-//# sourceMappingURL=command.js.map
+/* Add Environment options */
+export const addEnvironmentOptions = (command = new YeomanCommand()) => command
+    .option('--cwd', 'Path to use as current dir')
+    /* Environment options */
+    .option('--skip-install', 'Do not automatically install dependencies', false)
+    /* Generator options */
+    .option('--skip-cache', 'Do not remember prompt answers', false)
+    .option('--local-config-only', 'Generate .yo-rc-global.json locally', false)
+    .option('--ask-answered', 'Show prompts for already configured options', false)
+    /* Conflicter options */
+    .option('--force', 'Override every file', false)
+    .option('--dry-run', 'Print conflicts', false)
+    .option('--whitespace', 'Whitespace changes will not trigger conflicts', false)
+    .option('--bail', 'Fail on first conflict', false)
+    .option('--skip-yo-resolve', 'Ignore .yo-resolve files', false)
+    /* Hidden options, used for api */
+    .addOption(new Option('--skip-local-cache', 'Skip local answers cache').default(true).hideHelp())
+    .addOption(new Option('--skip-parse-options', 'Skip legacy options parsing').default(false).hideHelp())
+    .addOption(new Option('--experimental', 'Experimental features').default(false).hideHelp())
+    .addOption(new Option('--log-cwd', 'Path for log purpose').hideHelp());

package/dist/util/namespace.d.ts

@@ -1,80 +1,26 @@
+type AsNamespaceOptions = {
+    lookups?: string[];
+};
+export declare const defaultLookups: string[];
 /**
- * Parse a namespace
+ * Given a String `filepath`, tries to figure out the relative 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
+ * ### Examples:
  *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function toNamespace(namespace: string | YeomanNamespace): YeomanNamespace;
-/**
- * Convert a package name to a namespace object
+ *     this.namespace('backbone/all/index.js');
+ *     // => backbone:all
  *
- * @private
- * @param  {String} packageName
- * @return {YeomanNamespace}
- */
-export function namespaceFromPackageName(packageName: string): YeomanNamespace;
-/**
- * Convert a namespace to a namespace object
+ *     this.namespace('generator-backbone/model');
+ *     // => backbone:model
  *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function requireNamespace(namespace: string | YeomanNamespace): YeomanNamespace;
-/**
- * Test if the object is an Namespace instance.
+ *     this.namespace('backbone.js');
+ *     // => backbone
+ *
+ *     this.namespace('generator-mocha/backbone/model/index.js');
+ *     // => mocha:backbone:model
  *
- * @private
- * @param  {Object} namespace
- * @return {Boolean} True if namespace is a YeomanNamespace
+ * @param filepath
+ * @param lookups paths
  */
-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;
-}
+export declare const asNamespace: (filepath: string, { lookups }: AsNamespaceOptions) => string;
+export {};

package/dist/util/namespace.js

@@ -1,197 +1,63 @@
-import createdLogger from 'debug';
-const debug = createdLogger('yeoman:environment:namespace');
-// ===================== | == @ ======== scope ======== | ===== unscoped ===== | = : ========== generator ======== | = @ ===== semver ===== @  | = # ========= instanceId ======== | == + ======== method ======= |= flags = |
-const NAMESPACE_REGEX = /^(?:(@[a-z\d-~][a-z\d-._~]*)\/)?([a-z\d-~][a-z\d-._~]*)(?::((?:[a-z\d-~][a-z\d-._~]*:?)*))?(?:@([a-z\d-.~><+=^* ]*)@?)?(?:#((?:[a-z\d-~][a-z\d-._~]*|\*)))?(?:\+((?:[a-zA-Z\d]\w*\+?)*))?(\?)?$/;
-const groups = {
-    complete: 0,
-    scope: 1,
-    unscoped: 2,
-    generator: 3,
-    semver: 4,
-    instanceId: 5,
-    method: 6,
-    flags: 7,
-};
-const flags = { optional: '?' };
-export class YeomanNamespace {
-    constructor(parsed) {
-        this._original = parsed.complete;
-        this.scope = parsed.scope;
-        this.unscoped = parsed.unscoped;
-        this.generator = parsed.generator;
-        this.instanceId = parsed.instanceId;
-        this.semver = parsed.semver;
-        this.methods = parsed.method ? parsed.method.split('+') : parsed.methods;
-        this.flags = parsed.flags;
-        // Populate flags
-        if (this.flags) {
-            for (const [name, value] of Object.entries(flags)) {
-                if (this.flags === value) {
-                    this[name] = true;
-                }
-                else {
-                    delete this[name];
-                }
-            }
-        }
-        debug('Parsed namespace %o', this);
-    }
-    static parse(complete) {
-        const result = NAMESPACE_REGEX.exec(complete);
-        if (!result) {
-            debug('Namespace failed RegExp parse %s, using fallback', complete);
-            return null;
-        }
-        const parsed = { complete };
-        // Populate fields
-        for (const [name, value] of Object.entries(groups)) {
-            if (result[value]) {
-                parsed[name] = result[value];
-            }
-        }
-        return parsed;
-    }
-    _update(parsed) {
-        this.scope = parsed.scope || this.scope;
-        this.unscoped = parsed.unscoped || this.unscoped;
-        this.generator = parsed.generator || this.generator;
-        this.instanceId = parsed.instanceId || this.instanceId;
-        this.command = parsed.command || this.command;
-        this.flags = parsed.flags || this.flags;
-    }
-    get _scopeAddition() {
-        return this.scope ? `${this.scope}/` : '';
-    }
-    get generatorName() {
-        return this.generator ? `:${this.generator}` : '';
-    }
-    _semverAddition(post) {
-        if (!this.semver) {
-            return post ?? '';
-        }
-        if (post) {
-            return `@${this.semver}@${post}`;
-        }
-        return `@${this.semver}`;
-    }
-    get instanceName() {
-        return this.instanceId ? `#${this.instanceId}` : '';
-    }
-    get complete() {
-        let methods = '';
-        if (this.methods && this.methods.length > 0) {
-            methods = '+' + this.methods.join('+');
-        }
-        const postSemver = `${this.instanceName}${methods}${this.flags || ''}`;
-        return `${this.namespace}${this._semverAddition(postSemver)}`;
-    }
-    get packageNamespace() {
-        return `${this._scopeAddition}${this.unscoped}`;
-    }
-    get namespace() {
-        return `${this.packageNamespace}${this.generatorName}`;
-    }
-    set namespace(namespace) {
-        const parsed = YeomanNamespace.parse(namespace);
-        if (!parsed) {
-            throw new Error(`Error parsing namespace ${namespace}`);
-        }
-        this._update(parsed);
-    }
-    get unscopedNamespace() {
-        return `${this.unscoped}${this.generatorName}`;
-    }
-    get id() {
-        return `${this.namespace}${this.instanceName}`;
-    }
-    get generatorHint() {
-        return `${this._scopeAddition}generator-${this.unscoped}`;
-    }
-    get versionedHint() {
-        return this.semver ? `${this.generatorHint}@"${this.semver}"` : this.generatorHint;
-    }
-    with(newValues) {
-        const self = this;
-        return new YeomanNamespace({
-            ...self,
-            ...newValues,
-        });
-    }
-    toString() {
-        return this.complete;
-    }
-}
+import { parse } from 'node:path';
+import slash from 'slash';
+import { findLast } from 'lodash-es';
+import escapeStringRegexp from 'escape-string-regexp';
+export const defaultLookups = ['.', 'generators', 'lib/generators', 'dist/generators'];
 /**
- * Parse a namespace
+ * Given a String `filepath`, tries to figure out the relative 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) {
-    if (typeof complete !== 'string') {
-        return null;
-    }
-    const parsed = YeomanNamespace.parse(complete);
-    return parsed ? new YeomanNamespace(parsed) : null;
-}
-/**
- * Convert a namespace to a namespace object
+ * ### Examples:
  *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function toNamespace(namespace) {
-    return isNamespace(namespace) ? namespace : parseNamespace(namespace);
-}
-/**
- * Convert a package name to a namespace object
+ *     this.namespace('backbone/all/index.js');
+ *     // => backbone:all
  *
- * @private
- * @param  {String} packageName
- * @return {YeomanNamespace}
- */
-export function namespaceFromPackageName(packageName) {
-    const namespace = this.parseNamespace(packageName);
-    if (!namespace.unscoped.startsWith('generator-')) {
-        throw new Error(`${packageName} is not a valid generator package name`);
-    }
-    namespace.unscoped = namespace.unscoped.replace(/^generator-/, '');
-    return namespace;
-}
-/**
- * Convert a namespace to a namespace object
+ *     this.namespace('generator-backbone/model');
+ *     // => backbone:model
  *
- * @private
- * @param  {String | YeomanNamespace} namespace
- * @return {YeomanNamespace}
- */
-export function requireNamespace(namespace) {
-    const parsed = toNamespace(namespace);
-    if (!parsed) {
-        throw new Error(`Error parsing namespace ${namespace}`);
-    }
-    return parsed;
-}
-/**
- * Test if the object is an Namespace instance.
+ *     this.namespace('backbone.js');
+ *     // => backbone
+ *
+ *     this.namespace('generator-mocha/backbone/model/index.js');
+ *     // => mocha:backbone:model
  *
- * @private
- * @param  {Object} namespace
- * @return {Boolean} True if namespace is a YeomanNamespace
+ * @param filepath
+ * @param lookups paths
  */
-export function isNamespace(namespace) {
-    return namespace && namespace.constructor && namespace.constructor.name === 'YeomanNamespace';
-}
-//# sourceMappingURL=namespace.js.map
+export const asNamespace = (filepath, { lookups = defaultLookups }) => {
+    if (!filepath) {
+        throw new Error('Missing file path');
+    }
+    // Normalize path
+    let ns = slash(filepath);
+    // Ignore path before latest node_modules
+    const nodeModulesPath = '/node_modules/';
+    if (ns.includes(nodeModulesPath)) {
+        ns = ns.slice(ns.lastIndexOf(nodeModulesPath) + nodeModulesPath.length, ns.length);
+    }
+    // Cleanup extension and normalize path for differents OS
+    const parsed = parse(ns);
+    ns = parsed.dir ? `${parsed.dir}/${parsed.name}` : parsed.name;
+    // Sort lookups by length so biggest are removed first
+    const nsLookups = [...lookups, '..']
+        .map(found => slash(found))
+        .sort((a, b) => a.split('/').length - b.split('/').length)
+        .reverse();
+    // If `ns` contains a lookup dir in its path, remove it.
+    for (const lookup of nsLookups) {
+        // Only match full directory (begin with leading slash or start of input, end with trailing slash)
+        ns = ns.replace(new RegExp(`(?:/|^)${escapeStringRegexp(lookup)}(?=/)`, 'g'), '');
+    }
+    const folders = ns.split('/');
+    const scope = findLast(folders, folder => folder.startsWith('@'));
+    // Cleanup `ns` from unwanted parts and then normalize slashes to `:`
+    ns = ns
+        .replace(/\/\//g, '') // Remove double `/`
+        .replace(/(.*generator-)/, '') // Remove before `generator-`
+        .replace(/\/(index|main)$/, '') // Remove `/index` or `/main`
+        .replace(/^\//, '') // Remove leading `/`
+        .replace(/\/+/g, ':'); // Replace slashes by `:`
+    if (scope) {
+        ns = `${scope}/${ns}`;
+    }
+    return ns;
+};

package/dist/util/resolve.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve a module path
+ * @param  specifier - Filepath or module name
+ * @return           - The resolved path leading to the module
+ */
+export declare function resolveModulePath(specifier: string, resolvedOrigin?: string): Promise<string | undefined>;

package/dist/util/resolve.js

@@ -0,0 +1,40 @@
+import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
+import { realpath, stat } from 'node:fs/promises';
+import untildify from 'untildify';
+import { locatePath } from 'locate-path';
+import { defaultExtensions } from '../generator-lookup.js';
+/**
+ * Resolve a module path
+ * @param  specifier - Filepath or module name
+ * @return           - The resolved path leading to the module
+ */
+export async function resolveModulePath(specifier, resolvedOrigin) {
+    let maybeResolved = specifier;
+    if (maybeResolved.startsWith('.')) {
+        if (resolvedOrigin) {
+            maybeResolved = resolve(dirname(resolvedOrigin), '..', maybeResolved);
+        }
+        else {
+            throw new Error(`Specifier ${maybeResolved} could not be calculated`);
+        }
+    }
+    maybeResolved = untildify(maybeResolved);
+    maybeResolved = normalize(maybeResolved);
+    if (extname(maybeResolved) === '') {
+        maybeResolved += sep;
+    }
+    try {
+        let specStat = await stat(maybeResolved);
+        if (specStat.isSymbolicLink()) {
+            specStat = await stat(await realpath(maybeResolved));
+        }
+        if (specStat.isFile()) {
+            return maybeResolved;
+        }
+        if (specStat.isDirectory()) {
+            return await locatePath(defaultExtensions.map(ext => `index${ext}`).map(file => join(maybeResolved, file)));
+        }
+    }
+    catch { }
+    throw new Error(`Error resolving ${specifier}`);
+}

package/dist/util/util.d.ts

@@ -1,14 +1,7 @@
-export { default as log } from "./log.js";
+import { type SyncOptions } from 'execa';
+export declare const execaOutput: (cmg: string, args: string[], options: SyncOptions) => string | undefined;
 /**
- * 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
+ * Two-step argument splitting function that first splits arguments in quotes,
+ * and then splits up the remaining arguments if they are not part of a quote.
  */
-export function duplicateEnv(initialEnv: Environment): Environment;
-export function execaOutput(cmg: any, args: any, options: any): string | undefined;
-import Environment from '../environment.js';
+export declare function splitArgsFromString(argsString: string | string[]): string[];

package/dist/util/util.js

@@ -1,24 +1,5 @@
-/** @module env/util */
 import { execaSync } from 'execa';
-import GroupedQueue from 'grouped-queue';
-import Environment from '../environment.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
- */
-const duplicateEnv = initialEnv => {
-    // Hack: Create a clone of the environment with a new instance of `runLoop`
-    const env = Object.create(initialEnv);
-    env.runLoop = new GroupedQueue(Environment.queues, false);
-    return env;
-};
-const execaOutput = (cmg, args, options) => {
+export const execaOutput = (cmg, args, options) => {
     try {
         const result = execaSync(cmg, args, options);
         if (!result.failed) {
@@ -28,6 +9,26 @@ const execaOutput = (cmg, args, options) => {
     catch { }
     return undefined;
 };
-export { duplicateEnv, execaOutput };
-export { default as log } from './log.js';
-//# sourceMappingURL=util.js.map
+/**
+ * Two-step argument splitting function that first splits arguments in quotes,
+ * and then splits up the remaining arguments if they are not part of a quote.
+ */
+export function splitArgsFromString(argsString) {
+    if (Array.isArray(argsString)) {
+        return argsString;
+    }
+    let result = [];
+    if (!argsString) {
+        return result;
+    }
+    const quoteSeparatedArgs = argsString.split(/("[^"]*")/).filter(Boolean);
+    for (const arg of quoteSeparatedArgs) {
+        if (arg.includes('"')) {
+            result.push(arg.replace(/"/g, ''));
+        }
+        else {
+            result = result.concat(arg.trim().split(' '));
+        }
+    }
+    return result;
+}