.config/coc/extensions/node_modules/coc-prettier/lib/PrettierEditProvider.js

   1 "use strict";
   2 Object.defineProperty(exports, "__esModule", { value: true });
   3 const tslib_1 = require("tslib");
   4 const coc_nvim_1 = require("coc.nvim");
   5 const path_1 = tslib_1.__importDefault(require("path"));
   6 const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
   7 const errorHandler_1 = require("./errorHandler");
   8 const requirePkg_1 = require("./requirePkg");
   9 const utils_1 = require("./utils");
  10 /**
  11  * HOLD style parsers (for stylelint integration)
  12  */
  13 const STYLE_PARSERS = ['postcss', 'css', 'less', 'scss'];
  14 /**
  15  * Resolves the prettierconfig for the given file.
  16  *
  17  * @param filePath file's path
  18  */
  19 function resolveConfig(filePath, options) {
  20     return tslib_1.__awaiter(this, void 0, void 0, function* () {
  21         try {
  22             const localPrettier = (yield requirePkg_1.requireLocalPkg(path_1.default.dirname(filePath), 'prettier', { silent: true, ignoreBundled: true }));
  23             let prettierInstance = localPrettier;
  24             if (!prettierInstance && !options.onlyUseLocalVersion) {
  25                 prettierInstance = require('prettier');
  26             }
  27             const config = yield prettierInstance.resolveConfig(filePath, options);
  28             return { config };
  29         }
  30         catch (error) {
  31             return { config: null, error };
  32         }
  33     });
  34 }
  35 /**
  36  * Define which config should be used.
  37  * If a prettierconfig exists, it returns itself.
  38  * It merges prettierconfig into vscode's config (editorconfig).
  39  * Priority:
  40  * - additionalConfig
  41  * - prettierConfig
  42  * - vscodeConfig
  43  * @param hasPrettierConfig a prettierconfig exists
  44  * @param additionalConfig config we really want to see in. (range)
  45  * @param prettierConfig prettier's file config
  46  * @param vscodeConfig our config
  47  */
  48 function mergeConfig(hasPrettierConfig, additionalConfig, prettierConfig, vscodeConfig) {
  49     return hasPrettierConfig
  50         ? Object.assign({ parser: vscodeConfig.parser }, // always merge our inferred parser in
  51         prettierConfig, additionalConfig)
  52         : Object.assign(vscodeConfig, prettierConfig, additionalConfig);
  53 }
  54 /**
  55  * Format the given text with user's configuration.
  56  * @param text Text to format
  57  * @param path formatting file's path
  58  * @returns {string} formatted text
  59  */
  60 function format(text, { languageId, uri }, customOptions) {
  61     return tslib_1.__awaiter(this, void 0, void 0, function* () {
  62         let u = coc_nvim_1.Uri.parse(uri);
  63         const isUntitled = u.scheme == 'untitled';
  64         const fileName = u.fsPath;
  65         const vscodeConfig = utils_1.getConfig(u);
  66         const localOnly = vscodeConfig.onlyUseLocalVersion;
  67         const resolvedPrettier = yield utils_1.getPrettierInstance();
  68         if (!resolvedPrettier) {
  69             errorHandler_1.addToOutput(`Prettier module not found, prettier.onlyUseLocalVersion: ${vscodeConfig.onlyUseLocalVersion}`, 'Error');
  70         }
  71         let supportedLanguages = utils_1.allLanguages(resolvedPrettier);
  72         if (supportedLanguages.indexOf(languageId) == -1) {
  73             coc_nvim_1.workspace.showMessage(`${languageId} not supported by prettier`, 'error');
  74             return;
  75         }
  76         const dynamicParsers = utils_1.getParsersFromLanguageId(languageId, resolvedPrettier, isUntitled ? undefined : fileName);
  77         let useBundled = false;
  78         let parser;
  79         if (!dynamicParsers.length) {
  80             const bundledParsers = utils_1.getParsersFromLanguageId(languageId, require('prettier'), isUntitled ? undefined : fileName);
  81             parser = bundledParsers[0] || 'babylon';
  82             useBundled = true;
  83         }
  84         else if (dynamicParsers.includes(vscodeConfig.parser)) {
  85             // handle deprecated parser option (parser: "flow")
  86             parser = vscodeConfig.parser;
  87         }
  88         else {
  89             parser = dynamicParsers[0];
  90         }
  91         const doesParserSupportEslint = [
  92             'javascript',
  93             'javascriptreact',
  94             'typescript',
  95             'typescriptreact',
  96             'vue',
  97         ].includes(languageId);
  98         const { config: fileOptions, error } = yield resolveConfig(fileName, {
  99             editorconfig: true,
 100             onlyUseLocalVersion: localOnly,
 101             requireConfig: vscodeConfig.requireConfig,
 102         });
 103         const hasConfig = fileOptions != null;
 104         if (!hasConfig && vscodeConfig.requireConfig) {
 105             return text;
 106         }
 107         if (error) {
 108             errorHandler_1.addToOutput(`Failed to resolve config for ${fileName}. Falling back to the default config settings.`, 'Error');
 109         }
 110         const prettierOptions = mergeConfig(hasConfig, customOptions, fileOptions || {}, {
 111             printWidth: vscodeConfig.printWidth,
 112             tabWidth: vscodeConfig.tabWidth,
 113             singleQuote: vscodeConfig.singleQuote,
 114             jsxSingleQuote: vscodeConfig.jsxSingleQuote,
 115             trailingComma: vscodeConfig.trailingComma,
 116             bracketSpacing: vscodeConfig.bracketSpacing,
 117             jsxBracketSameLine: vscodeConfig.jsxBracketSameLine,
 118             parser,
 119             semi: vscodeConfig.semi,
 120             useTabs: vscodeConfig.useTabs,
 121             proseWrap: vscodeConfig.proseWrap,
 122             arrowParens: vscodeConfig.arrowParens,
 123         });
 124         if (vscodeConfig.tslintIntegration && parser === 'typescript') {
 125             return errorHandler_1.safeExecution(() => {
 126                 const prettierTslint = requirePkg_1.requireLocalPkg(u.fsPath, 'prettier-tslint')
 127                     .format;
 128                 // setUsedModule('prettier-tslint', 'Unknown', true)
 129                 return prettierTslint({
 130                     text,
 131                     filePath: fileName,
 132                     fallbackPrettierOptions: prettierOptions,
 133                 });
 134             }, text, fileName);
 135         }
 136         if (vscodeConfig.eslintIntegration && doesParserSupportEslint) {
 137             return errorHandler_1.safeExecution(() => {
 138                 const prettierEslint = requirePkg_1.requireLocalPkg(u.fsPath, 'prettier-eslint');
 139                 // setUsedModule('prettier-eslint', 'Unknown', true)
 140                 return prettierEslint({
 141                     text,
 142                     filePath: fileName,
 143                     fallbackPrettierOptions: prettierOptions,
 144                 });
 145             }, text, fileName);
 146         }
 147         if (vscodeConfig.stylelintIntegration && STYLE_PARSERS.includes(parser)) {
 148             const prettierStylelint = requirePkg_1.requireLocalPkg(u.fsPath, 'prettier-stylelint');
 149             return errorHandler_1.safeExecution(prettierStylelint.format({
 150                 text,
 151                 filePath: fileName,
 152                 prettierOptions,
 153             }), text, fileName);
 154         }
 155         if (!doesParserSupportEslint && useBundled) {
 156             let bundledPrettier = require('prettier');
 157             return errorHandler_1.safeExecution(() => {
 158                 const warningMessage = `prettier@${bundledPrettier.version} doesn't support ${languageId}. ` +
 159                     `Falling back to bundled prettier@${bundledPrettier.version}.`;
 160                 errorHandler_1.addToOutput(warningMessage, 'Warning');
 161                 // setUsedModule('prettier', bundledPrettier.version, true)
 162                 return bundledPrettier.format(text, prettierOptions);
 163             }, text, fileName);
 164         }
 165         // setUsedModule('prettier', localPrettier.version, false)
 166         return errorHandler_1.safeExecution(() => resolvedPrettier.format(text, prettierOptions), text, fileName);
 167     });
 168 }
 169 exports.format = format;
 170 function fullDocumentRange(document) {
 171     const lastLineId = document.lineCount - 1;
 172     let doc = coc_nvim_1.workspace.getDocument(document.uri);
 173     return vscode_languageserver_protocol_1.Range.create({ character: 0, line: 0 }, { character: doc.getline(lastLineId).length, line: lastLineId });
 174 }
 175 exports.fullDocumentRange = fullDocumentRange;
 176 class PrettierEditProvider {
 177     constructor(_fileIsIgnored) {
 178         this._fileIsIgnored = _fileIsIgnored;
 179     }
 180     provideDocumentRangeFormattingEdits(document, range, _options, _token) {
 181         return this._provideEdits(document, {
 182             rangeStart: document.offsetAt(range.start),
 183             rangeEnd: document.offsetAt(range.end),
 184         });
 185     }
 186     provideDocumentFormattingEdits(document, _options, _token) {
 187         return this._provideEdits(document, {});
 188     }
 189     _provideEdits(document, options) {
 190         return tslib_1.__awaiter(this, void 0, void 0, function* () {
 191             let fileName = coc_nvim_1.Uri.parse(document.uri).fsPath;
 192             if (!document.uri.startsWith('untitled') && this._fileIsIgnored(fileName)) {
 193                 return Promise.resolve([]);
 194             }
 195             const code = yield format(document.getText(), document, options);
 196             const edits = [yield vscode_languageserver_protocol_1.TextEdit.replace(fullDocumentRange(document), code)];
 197             const { disableSuccessMessage } = utils_1.getConfig();
 198             if (edits && edits.length && !disableSuccessMessage) {
 199                 coc_nvim_1.workspace.showMessage('Formatted by prettier');
 200             }
 201             errorHandler_1.addToOutput(`Formatted file: ${document.uri}`);
 202             errorHandler_1.addToOutput(`Prettier format edits: ${JSON.stringify(edits, null, 2)}`);
 203             return edits;
 204         });
 205     }
 206 }
 207 exports.default = PrettierEditProvider;
 208 //# sourceMappingURL=PrettierEditProvider.js.map