dprint/dist/dprint.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var minimist = _interopDefault(require('minimist'));
var core = require('@dprint/core');
var fs = require('fs');
var path = require('path');

function parseCommandLineArgs(args) {
    const argv = minimist(args, {
        string: ["config"],
        boolean: ["help", "version", "outputFilePaths", "outputResolvedConfig", "allowNodeModuleFiles", "duration", "init"],
    });
    return {
        allowNodeModuleFiles: argv["allowNodeModuleFiles"],
        config: getConfigFilePath(),
        init: argv["init"],
        showHelp: argv["h"] || argv["help"],
        showVersion: argv["v"] || argv["version"],
        outputFilePaths: argv["outputFilePaths"],
        outputResolvedConfig: argv["outputResolvedConfig"],
        duration: argv["duration"],
        filePatterns: argv._,
    };
    function getConfigFilePath() {
        return argv["c"] || argv["config"] || undefined;
    }
}

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

const projectTypeInfo = {
    values: [{
            name: "openSource",
            description: "Dprint is formatting an open source project.",
        }, {
            name: "commercialSponsored",
            description: "Dprint is formatting a closed source commercial project and your company sponsored dprint.",
        }, {
            name: "commercialDidNotSponsor",
            description: "Dprint is formatting a closed source commercial project and you want to forever enshrine your name "
                + "in source control for having specified this.",
        }],
};
function getMissingProjectTypeDiagnostic(config) {
    const validProjectTypes = projectTypeInfo.values.map(v => v.name);
    if (validProjectTypes.includes(config.projectType || ""))
        return undefined;
    const propertyName = "projectType";
    const largestValueName = validProjectTypes.map(s => s.length).sort().pop();
    return {
        propertyName,
        message: `The "${propertyName}" field is missing. You may specify any of the following possible values in the configuration file according to your `
            + `conscience and that will supress this warning.\n\n`
            + projectTypeInfo.values.map(value => ` * ${value.name} ${" ".repeat(largestValueName - value.name.length)}${value.description}`).join("\n"),
    };
}

function getPackageVersion() {
    return "0.11.1";
}

function getHelpText(plugins) {
    return `dprint v${getPackageVersion()}

Syntax:   dprint [options] [...file patterns]
Examples: dprint
          dprint "src/**/*.ts"
Options:
-h, --help              Outputs this message.
-v, --version           Outputs the version of the library and plugins.
--init                  Creates a dprint.config.js file in the current directory.
-c, --config            Configuration file to use (default: dprint.config.js)
--outputFilePaths       Outputs the list of file paths found for formatting without formatting the files.
--outputResolvedConfig  Outputs the resolved configuration from the configuration file.
--duration              Outputs how long the format took.
--allowNodeModuleFiles  Allows including files that have a node_modules directory in their path.
${getPluginTexts()}`;
    function getPluginTexts() {
        const prefix = "Plugins:";
        let result = prefix;
        if (plugins.length === 0)
            result += " [No plugins]";
        else {
            for (const plugin of plugins)
                result += `\n* ${plugin.name} v${plugin.version}`;
        }
        return result;
    }
}

function getVersionText(plugins) {
    return `dprint v${getPackageVersion()}${getPluginTexts()}`;
    function getPluginTexts() {
        let result = "";
        if (plugins.length === 0)
            result += " (No plugins)";
        else {
            for (const plugin of plugins)
                result += `\n${plugin.name} v${plugin.version}`;
        }
        return result;
    }
}

class KillSafeFileWriter {
    constructor(environment) {
        this.environment = environment;
        this.tempFiles = new Set();
        this.crashed = false;
        this.crashCleanup = () => {
            this.crashed = true;
            for (const filePath of this.tempFiles.values())
                this.tryDeleteFileSync(filePath);
            this.tempFiles.clear();
        };
        process.on("SIGINT", this.crashCleanup);
        process.on("SIGUSR1", this.crashCleanup);
        process.on("SIGUSR2", this.crashCleanup);
    }
    dispose() {
        return __awaiter(this, void 0, void 0, function* () {
            process.off("SIGINT", this.crashCleanup);
            process.off("SIGUSR1", this.crashCleanup);
            process.off("SIGUSR2", this.crashCleanup);
            const tempFiles = Array.from(this.tempFiles.values());
            return Promise.all(tempFiles.map(filePath => this.tryDeleteFile(filePath)));
        });
    }
    writeFile(filePath, fileText) {
        return __awaiter(this, void 0, void 0, function* () {
            const tempFilePath = this.getTempFileName(filePath);
            this.tempFiles.add(tempFilePath);
            yield this.environment.writeFile(tempFilePath, fileText);
            if (this.crashed) {
                this.tryDeleteFileSync(tempFilePath);
                return;
            }
            yield this.environment.rename(tempFilePath, filePath);
            this.tempFiles.delete(tempFilePath);
        });
    }
    tryDeleteFile(filePath) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                yield this.environment.unlink(filePath);
            }
            catch (_a) {
            }
        });
    }
    tryDeleteFileSync(filePath) {
        try {
            this.environment.unlinkSync(filePath);
        }
        catch (_a) {
        }
    }
    getTempFileName(filePath) {
        return filePath + ".dprint_temp";
    }
}

function throwError(message) {
    throw getError(message);
}
function getError(message) {
    return new Error(`[dprint]: ${message}`);
}

function readFile(filePath) {
    return new Promise((resolve, reject) => {
        fs.readFile(filePath, { encoding: "utf8" }, (err, text) => {
            if (err)
                reject(err);
            else
                resolve(text);
        });
    });
}
function writeFile(filePath, text) {
    return new Promise((resolve, reject) => {
        fs.writeFile(filePath, text, { encoding: "utf8" }, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function rename(oldFilePath, newFilePath) {
    return new Promise((resolve, reject) => {
        fs.rename(oldFilePath, newFilePath, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function exists(fileOrDirPath) {
    return new Promise((resolve, reject) => {
        try {
            fs.exists(fileOrDirPath, result => {
                resolve(result);
            });
        }
        catch (err) {
            reject(err);
        }
    });
}
function unlink(filePath) {
    return new Promise((resolve, reject) => {
        fs.unlink(filePath, err => {
            if (err)
                reject(err);
            else
                resolve();
        });
    });
}
function unlinkSync(filePath) {
    fs.unlinkSync(filePath);
}

function resolveConfigFile(filePath, environment) {
    return __awaiter(this, void 0, void 0, function* () {
        const resolvedFilePath = resolveConfigFilePath(filePath, environment);
        return {
            filePath: resolvedFilePath,
            config: yield getConfig(),
        };
        function getConfig() {
            var _a, _b;
            return __awaiter(this, void 0, void 0, function* () {
                let config;
                try {
                    try {
                        config = yield environment.require(resolvedFilePath);
                    }
                    catch (err) {
                        if (yield environment.exists(resolvedFilePath))
                            return throwError(`Error loading configuration file '${resolvedFilePath}'.\n\n${err}`);
                        else if (filePath == null) {
                            return throwError(`Could not find configuration file at '${resolvedFilePath}'. `
                                + `Did you mean to create one (dprint --init) or specify a --config option?\n\n`
                                + err);
                        }
                        else {
                            return throwError(`Could not find specified configuration file at '${resolvedFilePath}'. Did you mean to create it?\n\n` + err);
                        }
                    }
                    if (typeof config !== "object" || typeof config.config !== "object")
                        return throwError(`Expected an object to be exported on the 'config' named export of the configuration at '${resolvedFilePath}'.`);
                    else
                        return config.config;
                }
                catch (err) {
                    const plugins = (_b = (_a = config) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.plugins;
                    if (plugins instanceof Array)
                        plugins.forEach(p => { var _a, _b; return (_b = (_a = p) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a); });
                    throw err;
                }
            });
        }
    });
}
function resolveConfigFilePath(filePath, environment) {
    return environment.resolvePath(filePath || "dprint.config.js");
}

function runCli(args, environment) {
    return __awaiter(this, void 0, void 0, function* () {
        const options = parseCommandLineArgs(args);
        yield runCliWithOptions(options, environment);
    });
}
function runCliWithOptions(options, environment) {
    return __awaiter(this, void 0, void 0, function* () {
        const startDate = new Date();
        if (options.showHelp) {
            environment.log(getHelpText(yield safeGetPlugins()));
            return;
        }
        else if (options.showVersion) {
            environment.log(getVersionText(yield safeGetPlugins()));
            return;
        }
        else if (options.init) {
            yield createConfigFile(environment);
            return;
        }
        const { unresolvedConfiguration, configFilePath, plugins } = yield getUnresolvedConfigAndPlugins();
        try {
            yield runCliWithPlugins();
        }
        finally {
            plugins.forEach(p => { var _a, _b; return (_b = (_a = p).dispose) === null || _b === void 0 ? void 0 : _b.call(_a); });
        }
        if (options.duration) {
            const durationInSeconds = ((new Date()).getTime() - startDate.getTime()) / 1000;
            environment.log(`Duration: ${durationInSeconds.toFixed(2)}s`);
        }
        function runCliWithPlugins() {
            return __awaiter(this, void 0, void 0, function* () {
                const globalConfig = resolveGlobalConfigurationInternal();
                updatePluginsWithConfiguration();
                const filePaths = yield getFilePaths();
                if (options.outputResolvedConfig) {
                    outputResolvedConfiguration();
                    return;
                }
                else if (options.outputFilePaths) {
                    if (filePaths.length > 0) {
                        for (const filePath of filePaths)
                            environment.log(filePath);
                    }
                    else {
                        environment.log("Found 0 files.");
                    }
                    return;
                }
                const promises = [];
                const killSafeFileWriter = new KillSafeFileWriter(environment);
                try {
                    for (const filePath of filePaths) {
                        const promise = environment.readFile(filePath).then(fileText => {
                            const result = core.formatFileText({
                                filePath,
                                fileText,
                                plugins,
                            });
                            return result === fileText ? Promise.resolve() : killSafeFileWriter.writeFile(filePath, result);
                        }).catch(err => {
                            const errorText = err.toString().replace("[dprint]: ", "");
                            environment.error(`Error formatting file: ${filePath}\n\n${errorText}`);
                        });
                        promises.push(promise);
                    }
                    yield Promise.all(promises);
                }
                finally {
                    yield killSafeFileWriter.dispose();
                }
                function updatePluginsWithConfiguration() {
                    for (const plugin of plugins) {
                        plugin.initialize({
                            environment,
                            globalConfig,
                        });
                        for (const diagnostic of plugin.getConfigurationDiagnostics())
                            warnForConfigurationDiagnostic(diagnostic);
                    }
                }
                function outputResolvedConfiguration() {
                    environment.log(getText());
                    function getText() {
                        let text = `Global configuration: ${prettyPrintAsJson(globalConfig)}`;
                        for (const plugin of plugins)
                            text += `\n${plugin.name}: ${prettyPrintAsJson(plugin.getConfiguration())}`;
                        return text;
                    }
                    function prettyPrintAsJson(obj) {
                        const numSpaces = 2;
                        return JSON.stringify(obj, null, numSpaces);
                    }
                }
            });
        }
        function resolveGlobalConfigurationInternal() {
            const missingProjectTypeDiagnostic = getMissingProjectTypeDiagnostic(unresolvedConfiguration);
            const configResult = core.resolveConfiguration(getUnresolvedConfigStrippedOfCliSpecificConfig());
            for (const diagnostic of configResult.diagnostics)
                warnForConfigurationDiagnostic(diagnostic);
            if (missingProjectTypeDiagnostic)
                warnForConfigurationDiagnostic(missingProjectTypeDiagnostic);
            return configResult.config;
            function getUnresolvedConfigStrippedOfCliSpecificConfig() {
                const obj = Object.assign({}, unresolvedConfiguration);
                delete obj.excludes;
                delete obj.includes;
                return obj;
            }
        }
        function getFilePaths() {
            return __awaiter(this, void 0, void 0, function* () {
                const isInNodeModules = /[\/|\\]node_modules[\/|\\]/i;
                const allFilePaths = yield environment.glob(getFileGlobs());
                return options.allowNodeModuleFiles ? allFilePaths : allFilePaths.filter(filePath => !isInNodeModules.test(filePath));
                function getFileGlobs() {
                    return [...getIncludes(), ...getExcludes()];
                    function getIncludes() {
                        if (options.filePatterns.length > 0) {
                            if (!options.outputFilePaths && unresolvedConfiguration.includes && unresolvedConfiguration.includes.length > 0)
                                environment.warn("Ignoring the configuration file's includes because file patterns were provided to the command line.");
                            return options.filePatterns;
                        }
                        return unresolvedConfiguration.includes || [];
                    }
                    function getExcludes() {
                        if (!unresolvedConfiguration.excludes)
                            return [];
                        return unresolvedConfiguration.excludes.map(pattern => {
                            if (pattern.startsWith("!"))
                                return pattern;
                            return "!" + pattern;
                        });
                    }
                }
            });
        }
        function warnForConfigurationDiagnostic(diagnostic) {
            environment.warn(`[${environment.basename(configFilePath)}]: ${diagnostic.message}`);
        }
        function safeGetPlugins() {
            return __awaiter(this, void 0, void 0, function* () {
                try {
                    return (yield getUnresolvedConfigAndPlugins()).plugins;
                }
                catch (err) {
                    return [];
                }
            });
        }
        function getUnresolvedConfigAndPlugins() {
            return __awaiter(this, void 0, void 0, function* () {
                const { config: unresolvedConfiguration, filePath: configFilePath } = yield resolveConfigFile(options.config, environment);
                return {
                    unresolvedConfiguration,
                    configFilePath,
                    plugins: unresolvedConfiguration.plugins || [],
                };
            });
        }
    });
}
function createConfigFile(environment) {
    return __awaiter(this, void 0, void 0, function* () {
        const filePath = resolveConfigFilePath(undefined, environment);
        if (yield environment.exists(filePath)) {
            environment.warn(`Skipping initialization because a configuration file already exists at: ${filePath}`);
            return;
        }
        environment.writeFile(filePath, getDefaultConfigFileText());
        environment.log(`Created ${filePath}`);
        function getDefaultConfigFileText() {
            return `// @ts-check
const { TypeScriptPlugin } = require("dprint-plugin-typescript");
const { JsoncPlugin } = require("dprint-plugin-jsonc");

/** @type { import("dprint").Configuration } */
module.exports.config = {
    projectType: "openSource",
    plugins: [
        new TypeScriptPlugin({
        }),
        new JsoncPlugin({
            indentWidth: 2,
        }),
    ],
    includes: [
        "**/*.{ts,tsx,json,js,jsx}",
    ],
};
`;
        }
    });
}

class CliEnvironment extends core.CliLoggingEnvironment {
    constructor() {
        super(...arguments);
        this.fastGlob = require("fast-glob");
    }
    basename(fileOrDirPath) {
        return path.basename(fileOrDirPath);
    }
    resolvePath(fileOrDirPath) {
        return path.normalize(path.resolve(fileOrDirPath));
    }
    readFile(filePath) {
        return readFile(filePath);
    }
    writeFile(filePath, text) {
        return writeFile(filePath, text);
    }
    exists(filePath) {
        return exists(filePath);
    }
    glob(patterns) {
        return this.fastGlob(backSlashesToForward(patterns), {
            absolute: true,
            cwd: path.resolve("."),
        });
    }
    require(filePath) {
        return new Promise((resolve, reject) => {
            try {
                resolve(require(filePath));
            }
            catch (err) {
                reject(err);
            }
        });
    }
    rename(oldFilePath, newFilePath) {
        return rename(oldFilePath, newFilePath);
    }
    unlink(filePath) {
        return unlink(filePath);
    }
    unlinkSync(filePath) {
        unlinkSync(filePath);
    }
}
function backSlashesToForward(patterns) {
    return patterns.map(p => p.replace(/\\/g, "/"));
}

exports.CliEnvironment = CliEnvironment;
exports.runCli = runCli;