nx 20.8.4 → 22.7.7

package/src/utils/params.js

@@ -1,664 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaError = void 0;
-exports.convertToCamelCase = convertToCamelCase;
-exports.coerceTypesInOptions = coerceTypesInOptions;
-exports.convertAliases = convertAliases;
-exports.validateOptsAgainstSchema = validateOptsAgainstSchema;
-exports.validateObject = validateObject;
-exports.setDefaults = setDefaults;
-exports.applyVerbosity = applyVerbosity;
-exports.combineOptionsForExecutor = combineOptionsForExecutor;
-exports.combineOptionsForGenerator = combineOptionsForGenerator;
-exports.warnDeprecations = warnDeprecations;
-exports.convertSmartDefaultsIntoNamedParams = convertSmartDefaultsIntoNamedParams;
-exports.getPromptsForSchema = getPromptsForSchema;
-const logger_1 = require("./logger");
-function camelCase(input) {
-    if (input.indexOf('-') > 1) {
-        return input
-            .toLowerCase()
-            .replace(/-(.)/g, (match, group1) => group1.toUpperCase());
-    }
-    else {
-        return input;
-    }
-}
-function convertToCamelCase(parsed, schema) {
-    return Object.keys(parsed).reduce((m, c) => {
-        if (schema.properties[camelCase(c)]) {
-            return { ...m, [camelCase(c)]: parsed[c] };
-        }
-        else {
-            return { ...m, [c]: parsed[c] };
-        }
-    }, {});
-}
-/**
- * Coerces (and replaces) options identified as 'boolean' or 'number' in the Schema
- *
- * @param opts The options to check
- * @param schema The schema definition with types to check against
- *
- */
-function coerceTypesInOptions(opts, schema) {
-    Object.keys(opts).forEach((k) => {
-        const prop = findSchemaForProperty(k, schema);
-        opts[k] = coerceType(prop?.description, opts[k]);
-    });
-    return opts;
-}
-function coerceType(prop, value) {
-    if (!prop)
-        return value;
-    if (typeof value !== 'string' && value !== undefined)
-        return value;
-    if (prop.oneOf) {
-        for (let i = 0; i < prop.oneOf.length; ++i) {
-            const coerced = coerceType(prop.oneOf[i], value);
-            if (coerced !== value) {
-                return coerced;
-            }
-        }
-        return value;
-    }
-    else if (Array.isArray(prop.type)) {
-        for (let i = 0; i < prop.type.length; ++i) {
-            const coerced = coerceType({ type: prop.type[i] }, value);
-            if (coerced !== value) {
-                return coerced;
-            }
-        }
-        return value;
-    }
-    else if (normalizedPrimitiveType(prop.type) == 'boolean' &&
-        isConvertibleToBoolean(value)) {
-        return value === true || value == 'true';
-    }
-    else if (normalizedPrimitiveType(prop.type) == 'number' &&
-        isConvertibleToNumber(value)) {
-        return Number(value);
-    }
-    else if (prop.type == 'array') {
-        return value.split(',').map((v) => coerceType(prop.items, v));
-    }
-    else {
-        return value;
-    }
-}
-/**
- * Converts any options passed in with short aliases to their full names if found
- * Unmatched options are added to opts['--']
- *
- * @param opts The options passed in by the user
- * @param schema The schema definition to check against
- */
-function convertAliases(opts, schema, excludeUnmatched) {
-    return Object.keys(opts).reduce((acc, k) => {
-        const prop = findSchemaForProperty(k, schema);
-        if (prop) {
-            acc[prop.name] = opts[k];
-        }
-        else if (excludeUnmatched) {
-            if (!acc['--']) {
-                acc['--'] = [];
-            }
-            acc['--'].push({
-                name: k,
-                possible: [],
-            });
-        }
-        else {
-            acc[k] = opts[k];
-        }
-        return acc;
-    }, {});
-}
-class SchemaError {
-    constructor(message) {
-        this.message = message;
-    }
-}
-exports.SchemaError = SchemaError;
-function validateOptsAgainstSchema(opts, schema) {
-    validateObject(opts, schema, schema.definitions || {});
-}
-function validateObject(opts, schema, definitions) {
-    if (schema.anyOf) {
-        const errors = [];
-        for (const s of schema.anyOf) {
-            try {
-                validateObject(opts, s, definitions);
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        }
-        if (errors.length === schema.anyOf.length) {
-            throw new Error(`Options did not match schema. Please fix any of the following errors:\n${errors
-                .map((e) => ' - ' + e.message)
-                .join('\n')}`);
-        }
-    }
-    if (schema.oneOf) {
-        const matches = [];
-        const errors = [];
-        for (const propertyDescription of schema.oneOf) {
-            try {
-                validateObject(opts, propertyDescription, definitions);
-                matches.push(propertyDescription);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        // If the options matched none of the oneOf property descriptions
-        if (matches.length === 0) {
-            throw new Error(`Options did not match schema: ${JSON.stringify(opts, null, 2)}.\nPlease fix 1 of the following errors:\n${errors
-                .map((e) => ' - ' + e.message)
-                .join('\n')}`);
-        }
-        // If the options matched none of the oneOf property descriptions
-        if (matches.length > 1) {
-            throw new Error(`Options did not match schema: ${JSON.stringify(opts, null, 2)}.\nShould only match one of \n${matches
-                .map((m) => ' - ' + JSON.stringify(m))
-                .join('\n')}`);
-        }
-    }
-    (schema.required ?? []).forEach((p) => {
-        if (opts[p] === undefined) {
-            throw new SchemaError(`Required property '${p}' is missing`);
-        }
-    });
-    if (schema.additionalProperties !== undefined &&
-        schema.additionalProperties !== true) {
-        Object.keys(opts).find((p) => {
-            if (Object.keys(schema.properties ?? {}).indexOf(p) === -1 &&
-                (!schema.patternProperties ||
-                    !Object.keys(schema.patternProperties).some((pattern) => new RegExp(pattern).test(p)))) {
-                if (p === '_') {
-                    throw new SchemaError(`Schema does not support positional arguments. Argument '${opts[p]}' found`);
-                }
-                else if (schema.additionalProperties === false) {
-                    throw new SchemaError(`'${p}' is not found in schema`);
-                }
-                else if (typeof schema.additionalProperties === 'object') {
-                    validateProperty(p, opts[p], schema.additionalProperties, definitions);
-                }
-            }
-        });
-    }
-    Object.keys(opts).forEach((p) => {
-        validateProperty(p, opts[p], (schema.properties ?? {})[p], definitions);
-        if (schema.patternProperties) {
-            Object.keys(schema.patternProperties).forEach((pattern) => {
-                if (new RegExp(pattern).test(p)) {
-                    validateProperty(p, opts[p], schema.patternProperties[pattern], definitions);
-                }
-            });
-        }
-    });
-}
-function validateProperty(propName, value, schema, definitions) {
-    if (!schema)
-        return;
-    if (schema.$ref) {
-        schema = resolveDefinition(schema.$ref, definitions);
-    }
-    if (schema.oneOf) {
-        if (!Array.isArray(schema.oneOf))
-            throw new Error(`Invalid schema file. oneOf must be an array.`);
-        const passes = schema.oneOf.filter((r) => {
-            try {
-                const rule = { type: schema.type, ...r };
-                validateProperty(propName, value, rule, definitions);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
-        }).length === 1;
-        if (!passes)
-            throwInvalidSchema(propName, schema);
-        return;
-    }
-    if (schema.anyOf) {
-        if (!Array.isArray(schema.anyOf))
-            throw new Error(`Invalid schema file. anyOf must be an array.`);
-        let passes = false;
-        schema.anyOf.forEach((r) => {
-            try {
-                const rule = { type: schema.type, ...r };
-                validateProperty(propName, value, rule, definitions);
-                passes = true;
-            }
-            catch (e) { }
-        });
-        if (!passes)
-            throwInvalidSchema(propName, schema);
-        return;
-    }
-    if (schema.allOf) {
-        if (!Array.isArray(schema.allOf))
-            throw new Error(`Invalid schema file. allOf must be an array.`);
-        if (!schema.allOf.every((r) => {
-            try {
-                const rule = { type: schema.type, ...r };
-                validateProperty(propName, value, rule, definitions);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
-        })) {
-            throwInvalidSchema(propName, schema);
-        }
-        return;
-    }
-    const isPrimitive = typeof value !== 'object';
-    if (isPrimitive) {
-        if (schema.const !== undefined && value !== schema.const) {
-            throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' should be '${schema.const}'.`);
-        }
-        if (Array.isArray(schema.type)) {
-            const passes = schema.type.some((t) => {
-                try {
-                    const rule = { type: t };
-                    validateProperty(propName, value, rule, definitions);
-                    return true;
-                }
-                catch (e) {
-                    return false;
-                }
-            });
-            if (!passes) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' should be a '${schema.type}'.`);
-            }
-        }
-        else if (schema.type &&
-            typeof value !== normalizedPrimitiveType(schema.type)) {
-            throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' should be a '${schema.type}'.`);
-        }
-        if (schema.enum && !schema.enum.includes(value)) {
-            throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' should be one of ${schema.enum.join(',')}.`);
-        }
-        if (schema.type === 'number') {
-            if (typeof schema.multipleOf === 'number' &&
-                value % schema.multipleOf !== 0) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. ${value} should be a multiple of ${schema.multipleOf}.`);
-            }
-            if (typeof schema.minimum === 'number' && value < schema.minimum) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. ${value} should be at least ${schema.minimum}`);
-            }
-            if (typeof schema.exclusiveMinimum === 'number' &&
-                value <= schema.exclusiveMinimum) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. ${value} should be greater than ${schema.exclusiveMinimum}`);
-            }
-            if (typeof schema.maximum === 'number' && value > schema.maximum) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. ${value} should be at most ${schema.maximum}`);
-            }
-            if (typeof schema.exclusiveMaximum === 'number' &&
-                value >= schema.exclusiveMaximum) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. ${value} should be less than ${schema.exclusiveMaximum}`);
-            }
-        }
-        if (schema.type === 'string') {
-            if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' should match the pattern '${schema.pattern}'.`);
-            }
-            if (typeof schema.minLength === 'number' &&
-                value.length < schema.minLength) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' (${value.length} character(s)) should have at least ${schema.minLength} character(s).`);
-            }
-            if (typeof schema.maxLength === 'number' &&
-                value.length > schema.maxLength) {
-                throw new SchemaError(`Property '${propName}' does not match the schema. '${value}' (${value.length} character(s)) should have at most ${schema.maxLength} character(s).`);
-            }
-        }
-    }
-    else if (Array.isArray(value)) {
-        if (schema.type !== 'array')
-            throwInvalidSchema(propName, schema);
-        value.forEach((valueInArray) => validateProperty(propName, valueInArray, schema.items || {}, definitions));
-    }
-    else {
-        if (schema.type !== 'object')
-            throwInvalidSchema(propName, schema);
-        validateObject(value, schema, definitions);
-    }
-}
-/**
- * Unfortunately, due to use supporting Angular Devkit, we have to do the following
- * conversions.
- */
-function normalizedPrimitiveType(type) {
-    if (type === 'integer')
-        return 'number';
-    return type;
-}
-function throwInvalidSchema(propName, schema) {
-    throw new SchemaError(`Property '${propName}' does not match the schema.\n${JSON.stringify(schema, null, 2)}'`);
-}
-function setDefaults(opts, schema) {
-    setDefaultsInObject(opts, schema.properties || {}, schema.definitions || {});
-    return opts;
-}
-function setDefaultsInObject(opts, properties, definitions) {
-    Object.keys(properties).forEach((p) => {
-        setPropertyDefault(opts, p, properties[p], definitions);
-    });
-}
-function setPropertyDefault(opts, propName, schema, definitions) {
-    if (schema.$ref) {
-        schema = resolveDefinition(schema.$ref, definitions);
-    }
-    if (schema.type !== 'object' && schema.type !== 'array') {
-        if (opts[propName] === undefined && schema.default !== undefined) {
-            opts[propName] = schema.default;
-        }
-    }
-    else if (schema.type === 'array') {
-        const items = schema.items || {};
-        if (opts[propName] &&
-            Array.isArray(opts[propName]) &&
-            items.type === 'object') {
-            opts[propName].forEach((valueInArray) => setDefaultsInObject(valueInArray, items.properties || {}, definitions));
-        }
-        else if (!opts[propName] && schema.default) {
-            opts[propName] = schema.default;
-        }
-    }
-    else {
-        const wasUndefined = opts[propName] === undefined;
-        if (wasUndefined) {
-            // We need an object to set values onto
-            opts[propName] = {};
-        }
-        setDefaultsInObject(opts[propName], schema.properties || {}, definitions);
-        // If the property was initially undefined but no properties were added, we remove it again instead of having an {}
-        if (wasUndefined && Object.keys(opts[propName]).length === 0) {
-            delete opts[propName];
-        }
-    }
-}
-function resolveDefinition(ref, definitions) {
-    if (!ref.startsWith('#/definitions/')) {
-        throw new Error(`$ref should start with "#/definitions/"`);
-    }
-    const definition = ref.split('#/definitions/')[1];
-    if (!definitions[definition]) {
-        throw new Error(`Cannot resolve ${ref}`);
-    }
-    return definitions[definition];
-}
-function applyVerbosity(options, schema, isVerbose) {
-    if ((schema.additionalProperties === true || 'verbose' in schema.properties) &&
-        isVerbose) {
-        options['verbose'] = true;
-    }
-}
-function combineOptionsForExecutor(commandLineOpts, config, target, schema, defaultProjectName, relativeCwd, isVerbose = false) {
-    const r = convertAliases(coerceTypesInOptions(convertToCamelCase(commandLineOpts, schema), schema), schema, false);
-    let combined = target.options || {};
-    if (config && target.configurations && target.configurations[config]) {
-        Object.assign(combined, target.configurations[config]);
-    }
-    combined = convertAliases(combined, schema, false);
-    Object.assign(combined, r);
-    convertSmartDefaultsIntoNamedParams(combined, schema, defaultProjectName, relativeCwd);
-    warnDeprecations(combined, schema);
-    setDefaults(combined, schema);
-    validateOptsAgainstSchema(combined, schema);
-    applyVerbosity(combined, schema, isVerbose);
-    return combined;
-}
-async function combineOptionsForGenerator(commandLineOpts, collectionName, generatorName, projectsConfigurations, nxJsonConfiguration, schema, isInteractive, defaultProjectName, relativeCwd, isVerbose = false) {
-    const generatorDefaults = projectsConfigurations
-        ? getGeneratorDefaults(defaultProjectName, projectsConfigurations, nxJsonConfiguration, collectionName, generatorName)
-        : {};
-    let combined = convertAliases(coerceTypesInOptions({ ...generatorDefaults, ...commandLineOpts }, schema), schema, false);
-    warnDeprecations(combined, schema);
-    convertSmartDefaultsIntoNamedParams(combined, schema, defaultProjectName, relativeCwd);
-    if (isInteractive && isTTY()) {
-        combined = await promptForValues(combined, schema, projectsConfigurations);
-    }
-    setDefaults(combined, schema);
-    validateOptsAgainstSchema(combined, schema);
-    applyVerbosity(combined, schema, isVerbose);
-    return combined;
-}
-function warnDeprecations(opts, schema) {
-    Object.keys(opts).forEach((option) => {
-        const deprecated = schema.properties[option]?.['x-deprecated'];
-        if (deprecated) {
-            logger_1.logger.warn(`Option "${option}" is deprecated${typeof deprecated == 'string' ? ': ' + deprecated : '.'}`);
-        }
-    });
-}
-function convertSmartDefaultsIntoNamedParams(opts, schema, defaultProjectName, relativeCwd) {
-    const argv = opts['_'] || [];
-    const usedPositionalArgs = {};
-    Object.entries(schema.properties).forEach(([k, v]) => {
-        if (opts[k] === undefined &&
-            v.$default !== undefined &&
-            v.$default.$source === 'argv' &&
-            argv[v.$default.index]) {
-            usedPositionalArgs[v.$default.index] = true;
-            opts[k] = coerceType(v, argv[v.$default.index]);
-        }
-        else if (v.$default !== undefined && v.$default.$source === 'unparsed') {
-            opts[k] = opts['__overrides_unparsed__'] || [];
-        }
-        else if (opts[k] === undefined &&
-            v.$default !== undefined &&
-            v.$default.$source === 'projectName' &&
-            defaultProjectName) {
-            opts[k] = defaultProjectName;
-        }
-        else if (opts[k] === undefined &&
-            v.format === 'path' &&
-            v.visible === false &&
-            relativeCwd) {
-            opts[k] = relativeCwd.replace(/\\/g, '/');
-        }
-        else if (opts[k] === undefined &&
-            v.$default !== undefined &&
-            v.$default.$source === 'workingDirectory' &&
-            relativeCwd) {
-            opts[k] = relativeCwd.replace(/\\/g, '/');
-        }
-    });
-    const leftOverPositionalArgs = [];
-    for (let i = 0; i < argv.length; ++i) {
-        if (!usedPositionalArgs[i]) {
-            leftOverPositionalArgs.push(argv[i]);
-        }
-    }
-    if (leftOverPositionalArgs.length === 0) {
-        delete opts['_'];
-    }
-    else {
-        opts['_'] = leftOverPositionalArgs;
-    }
-    delete opts['__overrides_unparsed__'];
-}
-function getGeneratorDefaults(projectName, projectsConfigurations, nxJsonConfiguration, collectionName, generatorName) {
-    let defaults = {};
-    if (nxJsonConfiguration?.generators) {
-        if (nxJsonConfiguration.generators[collectionName]?.[generatorName]) {
-            defaults = {
-                ...defaults,
-                ...nxJsonConfiguration.generators[collectionName][generatorName],
-            };
-        }
-        if (nxJsonConfiguration.generators[`${collectionName}:${generatorName}`]) {
-            defaults = {
-                ...defaults,
-                ...nxJsonConfiguration.generators[`${collectionName}:${generatorName}`],
-            };
-        }
-    }
-    if (projectName &&
-        projectsConfigurations?.projects[projectName]?.generators) {
-        const g = projectsConfigurations.projects[projectName].generators;
-        if (g[collectionName] && g[collectionName][generatorName]) {
-            defaults = { ...defaults, ...g[collectionName][generatorName] };
-        }
-        if (g[`${collectionName}:${generatorName}`]) {
-            defaults = {
-                ...defaults,
-                ...g[`${collectionName}:${generatorName}`],
-            };
-        }
-    }
-    return defaults;
-}
-function getPromptsForSchema(opts, schema, projectsConfigurations) {
-    const prompts = [];
-    Object.entries(schema.properties).forEach(([k, v]) => {
-        if (v['x-prompt'] && opts[k] === undefined) {
-            const question = {
-                name: k,
-            };
-            if (v.default) {
-                question.initial = v.default;
-            }
-            // Normalize x-prompt
-            if (typeof v['x-prompt'] === 'string') {
-                const message = v['x-prompt'];
-                if (v.type === 'boolean') {
-                    v['x-prompt'] = {
-                        type: 'confirm',
-                        message,
-                    };
-                }
-                else if (v.type === 'array' && v.items?.enum) {
-                    v['x-prompt'] = {
-                        type: 'multiselect',
-                        items: v.items.enum,
-                        message,
-                    };
-                }
-                else {
-                    v['x-prompt'] = {
-                        type: 'input',
-                        message,
-                    };
-                }
-            }
-            question.message = v['x-prompt'].message;
-            question.validate = (s) => {
-                try {
-                    validateProperty(k, s, v, schema.definitions || {});
-                    return true;
-                }
-                catch (e) {
-                    return e.message;
-                }
-            };
-            // Limit the number of choices displayed so that the prompt fits on the screen
-            const limitForChoicesDisplayed = process.stdout.rows - question.message.split('\n').length;
-            if (v.type === 'string' && v.enum && Array.isArray(v.enum)) {
-                question.type = 'autocomplete';
-                question.choices = [...v.enum];
-                question.limit = limitForChoicesDisplayed;
-            }
-            else if (v.type === 'string' &&
-                (v.$default?.$source === 'projectName' ||
-                    k === 'project' ||
-                    k === 'projectName' ||
-                    v['x-dropdown'] === 'projects') &&
-                projectsConfigurations) {
-                question.type = 'autocomplete';
-                question.choices = Object.keys(projectsConfigurations.projects);
-                question.limit = limitForChoicesDisplayed;
-            }
-            else if (v.type === 'number' || v['x-prompt'].type == 'number') {
-                question.type = 'numeral';
-            }
-            else if (v['x-prompt'].type == 'confirmation' ||
-                v['x-prompt'].type == 'confirm') {
-                question.type = 'confirm';
-            }
-            else if (v['x-prompt'].items) {
-                question.type =
-                    v['x-prompt'].multiselect || v.type === 'array'
-                        ? 'multiselect'
-                        : 'autocomplete';
-                question.choices =
-                    v['x-prompt'].items &&
-                        v['x-prompt'].items.map((item) => {
-                            if (typeof item == 'string') {
-                                return item;
-                            }
-                            else {
-                                return {
-                                    message: item.label,
-                                    name: item.value,
-                                };
-                            }
-                        });
-                question.limit = limitForChoicesDisplayed;
-            }
-            else if (v.type === 'boolean') {
-                question.type = 'confirm';
-            }
-            else {
-                question.type = 'input';
-            }
-            prompts.push(question);
-        }
-    });
-    return prompts;
-}
-async function promptForValues(opts, schema, projectsConfigurations) {
-    return await (await Promise.resolve().then(() => require('enquirer')))
-        .prompt(getPromptsForSchema(opts, schema, projectsConfigurations))
-        .then((values) => ({ ...opts, ...values }))
-        .catch((e) => {
-        console.error(e);
-        process.exit(0);
-    });
-}
-function findSchemaForProperty(propName, schema) {
-    if (propName in schema.properties) {
-        return {
-            name: propName,
-            description: schema.properties[propName],
-        };
-    }
-    const found = Object.entries(schema.properties).find(([_, d]) => d.alias === propName ||
-        (Array.isArray(d.aliases) && d.aliases.includes(propName)));
-    if (found) {
-        const [name, description] = found;
-        return { name, description };
-    }
-    return null;
-}
-function isTTY() {
-    return !!process.stdout.isTTY && process.env['CI'] !== 'true';
-}
-/**
- * Verifies whether the given value can be converted to a boolean
- * @param value
- */
-function isConvertibleToBoolean(value) {
-    if ('boolean' === typeof value) {
-        return true;
-    }
-    if ('string' === typeof value && /true|false/.test(value)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Verifies whether the given value can be converted to a number
- * @param value
- */
-function isConvertibleToNumber(value) {
-    // exclude booleans explicitly
-    if ('boolean' === typeof value) {
-        return false;
-    }
-    return !isNaN(+value);
-}

package/src/utils/path.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePath = normalizePath;
-exports.joinPathFragments = joinPathFragments;
-exports.getCwd = getCwd;
-const path = require("path");
-const workspace_root_1 = require("./workspace-root");
-function removeWindowsDriveLetter(osSpecificPath) {
-    return osSpecificPath.replace(/^[a-zA-Z]:/, '');
-}
-/**
- * Coverts an os specific path to a unix style path. Use this when writing paths to config files.
- * This should not be used to read files on disk because of the removal of Windows drive letters.
- */
-function normalizePath(osSpecificPath) {
-    return removeWindowsDriveLetter(osSpecificPath).split('\\').join('/');
-}
-/**
- * Normalized path fragments and joins them. Use this when writing paths to config files.
- * This should not be used to read files on disk because of the removal of Windows drive letters.
- */
-function joinPathFragments(...fragments) {
-    return normalizePath(path.join(...fragments));
-}
-/**
- * When running a script with the package manager (e.g. `npm run`), the package manager will
- * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
- * to the folder where it found it. The actual working directory is stored in the INIT_CWD
- * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
- *
- * @returns The path to the current working directory.
- */
-function getCwd() {
-    return process.env.INIT_CWD?.startsWith(workspace_root_1.workspaceRoot)
-        ? process.env.INIT_CWD
-        : process.cwd();
-}