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

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

@@ -0,0 +1,26 @@
+type AsNamespaceOptions = {
+    lookups?: string[];
+};
+export declare const defaultLookups: string[];
+/**
+ * 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 filepath
+ * @param lookups paths
+ */
+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

@@ -0,0 +1,7 @@
+import { type SyncOptions } from 'execa';
+export declare const execaOutput: (cmg: string, args: string[], options: SyncOptions) => string | undefined;
+/**
+ * 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 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.7",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "keywords": [
     "development",
@@ -22,21 +22,18 @@
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/index.d.js",
       "import": "./dist/index.js"
     },
-    "./cli/*": "./dist/cli/*.js",
-    "./lib/*": "./dist/*.js",
-    "./lib/util/*": "./dist/util/*.js",
-    "./transform": "./dist/util/transform.js",
-    "./package.json": "./package.json",
-    "./namespace": "./dist/util/namespace.js",
-    "./cli": "./dist/cli/index.js"
+    "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "bin": {
-    "yoe": "dist/cli/index.js"
+    "yoe": "bin/bin.cjs"
   },
   "files": [
+    "bin",
     "dist"
   ],
   "scripts": {
@@ -54,8 +51,6 @@
     "test-base": "c8 esmocha test/environment*.js test/store.js test/util.js test/adapter.js",
     "test-environment": "c8 esmocha test/environment.js",
     "test-generators": "c8 esmocha test/generators.js",
-    "test-namespace": "c8 esmocha test/namespace.js test/flags.js",
-    "test-repository": "c8 esmocha test/repository.js",
     "test-resolver": "c8 esmocha test/resolver.js"
   },
   "config": {
@@ -63,61 +58,53 @@
   },
   "dependencies": {
     "@npmcli/arborist": "^6.2.9",
-    "@yeoman/types": "^0.0.1",
-    "are-we-there-yet": "^4.0.0",
+    "@yeoman/adapter": "^0.3.0",
+    "@yeoman/conflicter": "^0.6.0",
+    "@yeoman/namespace": "^1.0.0",
+    "@yeoman/transform": "^1.0.0",
+    "@yeoman/types": "^0.5.0",
     "arrify": "^3.0.0",
-    "binaryextensions": "^4.18.0",
     "chalk": "^5.2.0",
-    "cli-table": "^0.3.11",
-    "commander": "7.1.0",
-    "dateformat": "^5.0.3",
+    "commander": "^10.0.1",
     "debug": "^4.3.4",
-    "diff": "^5.1.0",
     "escape-string-regexp": "^5.0.0",
     "execa": "^7.1.1",
-    "find-up": "^6.3.0",
-    "globby": "^11.0.1",
+    "fly-import": "^0.2.0",
+    "globby": "^13.1.4",
     "grouped-queue": "^2.0.0",
-    "inquirer": "^9.2.1",
-    "is-scoped": "^3.0.0",
-    "isbinaryfile": "^5.0.0",
+    "locate-path": "^7.2.0",
     "lodash-es": "^4.17.21",
     "log-symbols": "^5.1.0",
     "mem-fs": "^3.0.0",
     "mem-fs-editor": "^10.0.1",
-    "minimatch": "^3.0.4",
     "npmlog": "^7.0.1",
-    "p-queue": "^7.3.4",
-    "p-transform": "^2.0.1",
-    "pacote": "^15.1.3",
     "preferred-pm": "^3.0.3",
-    "pretty-bytes": "^6.1.0",
     "semver": "^7.5.0",
     "slash": "^5.0.1",
-    "strip-ansi": "^7.0.1",
-    "text-table": "^0.2.0",
-    "textextensions": "^5.16.0",
     "untildify": "^4.0.0",
     "yeoman-generator": "^5.8.0"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.7",
+    "@types/semver": "^7.5.0",
     "c8": "^7.13.0",
     "cpy-cli": "^4.2.0",
-    "esmocha": "^0.1.4",
+    "esmocha": "^1.0.1",
     "fs-extra": "^11.1.1",
+    "inquirer": "^9.2.1",
     "jsdoc": "^4.0.2",
     "prettier": "^2.8.8",
     "prettier-plugin-packagejson": "^2.4.3",
     "rimraf": "^5.0.0",
     "sinon": "^15.0.4",
     "sinon-test": "^3.1.5",
+    "strip-ansi": "^7.0.1",
     "tui-jsdoc-template": "^1.2.2",
     "typescript": "^5.0.4",
     "xo": "0.54.2",
     "yeoman-assert": "^3.1.1",
     "yeoman-generator": "^5.8.0",
-    "yeoman-test": "^8.0.0-alpha.0"
+    "yeoman-test": "^8.0.0-beta.5"
   },
   "peerDependencies": {
     "mem-fs": "^3.0.0"

package/readme.md

@@ -17,12 +17,11 @@ $ npm install yeoman-environment
 Full documentation available [here](http://yeoman.io/authoring/integrating-yeoman.html).
 
 ```js
-import yeoman from 'yeoman-environment';
-const env = yeoman.createEnv();
+import { createEnv } from 'yeoman-environment';
 
 // The #lookup() method will search the user computer for installed generators
 // The search if done from the current working directory
-env.lookup();
+await env.lookup();
 await env.run('angular', { skipInstall: true });
 ```