volar-service-prettier 0.0.31 → 0.0.32

package/index.d.ts

@@ -1,13 +1,10 @@
-import type { ServicePlugin, ServiceEnvironment } from '@volar/language-service';
-import type { Options, ResolveConfigOptions } from 'prettier';
-export declare function create(options?: {
-    /**
-     * Languages to be formatted by prettier.
-     *
-     * @default
-     * ['html', 'css', 'scss', 'typescript', 'javascript']
-     */
-    languages?: string[];
+import type { DocumentSelector, FormattingOptions, Result, ServiceContext, ServicePlugin, TextDocument } from '@volar/language-service';
+import type { Options } from 'prettier';
+export declare function create(
+/**
+ * Prettier instance or getter to use.
+ */
+prettierInstanceOrGetter: typeof import('prettier') | ((context: ServiceContext) => Result<typeof import('prettier') | undefined>), { html, documentSelector, isFormattingEnabled, getFormattingOptions, }?: {
     html?: {
         /**
          * Preprocessing to break "contents" from "HTML tags".
@@ -17,29 +14,13 @@ export declare function create(options?: {
         breakContentsFromTags?: boolean;
     };
     /**
-     * Do not use settings from VSCode's `editor.tabSize` and temporary tabSize on status bar
+     * Languages to be formatted by prettier.
      *
-     * @see https://github.com/volarjs/services/issues/5
-     */
-    ignoreIdeOptions?: boolean;
-    /**
-     * Determine if IDE options should be used as a fallback if there's no Prettier specific settings in the workspace
-     */
-    useIdeOptionsFallback?: boolean;
-    /**
-     * Additional options to pass to Prettier
-     * This is useful, for instance, to add specific plugins you need.
-     */
-    additionalOptions?: (resolvedConfig: Options) => Options | Promise<Options>;
-    /**
-     * Options to use when resolving the Prettier config
-     */
-    resolveConfigOptions?: ResolveConfigOptions;
-    /**
-     * Prettier instance to use. If undefined, Prettier will be imported through a normal `import('prettier')`.
-     * This property is useful whenever you want to load a specific instance of Prettier (for instance, loading the Prettier version installed in the user's project)
+     * @default
+     * ['html', 'css', 'scss', 'typescript', 'javascript']
      */
-    prettier?: typeof import('prettier') | undefined;
-    getPrettier?: (serviceEnv: ServiceEnvironment) => typeof import('prettier') | undefined;
-}, getPrettierConfig?: (filePath: string, prettier: typeof import('prettier'), config?: ResolveConfigOptions) => Promise<Options>): ServicePlugin;
+    documentSelector?: DocumentSelector;
+    isFormattingEnabled?(prettier: typeof import('prettier'), document: TextDocument, context: ServiceContext): Result<boolean>;
+    getFormattingOptions?(prettier: typeof import('prettier'), document: TextDocument, formatOptions: FormattingOptions, context: ServiceContext): Result<Options>;
+}): ServicePlugin;
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -2,65 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = void 0;
 const vscode_uri_1 = require("vscode-uri");
-function create(options = {}, getPrettierConfig = async (filePath, prettier, config) => {
-    return await prettier.resolveConfig(filePath, config) ?? {};
-}) {
+function create(
+/**
+ * Prettier instance or getter to use.
+ */
+prettierInstanceOrGetter, { html, documentSelector = ['html', 'css', 'scss', 'typescript', 'javascript'], isFormattingEnabled = async (prettier, document) => {
+    const uri = vscode_uri_1.URI.parse(document.uri);
+    if (uri.scheme === 'file') {
+        const fileInfo = await prettier.getFileInfo(uri.fsPath, { ignorePath: '.prettierignore', resolveConfig: false });
+        if (fileInfo.ignored) {
+            return false;
+        }
+    }
+    return true;
+}, getFormattingOptions = async (prettier, document, formatOptions, context) => {
+    const filepath = vscode_uri_1.URI.parse(document.uri).fsPath;
+    const configOptions = await prettier.resolveConfig(filepath);
+    const editorOptions = await context.env.getConfiguration?.('prettier', document.uri);
+    return {
+        filepath,
+        tabWidth: formatOptions.tabSize,
+        useTabs: !formatOptions.insertSpaces,
+        ...editorOptions,
+        ...configOptions,
+    };
+}, } = {}) {
     return {
         name: 'prettier',
         create(context) {
-            let prettier;
-            try {
-                prettier = options.prettier
-                    ?? options.getPrettier?.(context.env)
-                    ?? require('prettier');
-            }
-            catch (e) {
-                throw new Error("Could not load Prettier: " + e);
-            }
-            const languages = options.languages ?? ['html', 'css', 'scss', 'typescript', 'javascript'];
+            let prettierInstanceOrPromise;
             return {
                 async provideDocumentFormattingEdits(document, _, formatOptions) {
-                    if (!languages.includes(document.languageId)) {
+                    if (!matchDocument(documentSelector, document)) {
                         return;
                     }
-                    const filePath = vscode_uri_1.URI.parse(document.uri).fsPath;
-                    const fileInfo = await prettier.getFileInfo(filePath, { ignorePath: '.prettierignore', resolveConfig: false });
-                    if (fileInfo.ignored) {
+                    prettierInstanceOrPromise ??= typeof prettierInstanceOrGetter === 'function'
+                        ? prettierInstanceOrGetter(context)
+                        : prettierInstanceOrGetter;
+                    const prettier = await prettierInstanceOrPromise;
+                    if (!prettier) {
                         return;
                     }
-                    const filePrettierOptions = await getPrettierConfig(filePath, prettier, options.resolveConfigOptions);
-                    const editorPrettierOptions = await context.env.getConfiguration?.('prettier', document.uri);
-                    const ideFormattingOptions = formatOptions !== undefined && options.useIdeOptionsFallback // We need to check for options existing here because some editors might not have it
-                        ? {
-                            tabWidth: formatOptions.tabSize,
-                            useTabs: !formatOptions.insertSpaces,
-                        }
-                        : {};
-                    // Return a config with the following cascade:
-                    // - Prettier config file should always win if it exists, if it doesn't:
-                    // - Prettier config from the VS Code extension is used, if it doesn't exist:
-                    // - Use the editor's basic configuration settings
-                    const prettierOptions = returnObjectIfHasKeys(filePrettierOptions) || returnObjectIfHasKeys(editorPrettierOptions) || ideFormattingOptions;
-                    const currentPrettierConfig = {
-                        ...(options.additionalOptions
-                            ? await options.additionalOptions(prettierOptions)
-                            : prettierOptions),
-                        filepath: filePath,
-                    };
-                    if (!options.ignoreIdeOptions) {
-                        currentPrettierConfig.useTabs = !formatOptions.insertSpaces;
-                        currentPrettierConfig.tabWidth = formatOptions.tabSize;
+                    if (!isFormattingEnabled(prettier, document, context)) {
+                        return;
                     }
                     const fullText = document.getText();
                     let oldText = fullText;
-                    const isHTML = document.languageId === "html";
-                    if (isHTML && options.html?.breakContentsFromTags) {
+                    const isHTML = document.languageId === 'html';
+                    if (isHTML && html?.breakContentsFromTags) {
                         oldText = oldText
-                            .replace(/(<[a-z][^>]*>)([^ \n])/gi, "$1 $2")
-                            .replace(/([^ \n])(<\/[a-z][a-z0-9\t\n\r -]*>)/gi, "$1 $2");
+                            .replace(/(<[a-z][^>]*>)([^ \n])/gi, '$1 $2')
+                            .replace(/([^ \n])(<\/[a-z][a-z0-9\t\n\r -]*>)/gi, '$1 $2');
                     }
+                    const prettierOptions = await getFormattingOptions(prettier, document, formatOptions, context);
+                    const newText = await prettier.format(oldText, prettierOptions);
                     return [{
-                            newText: await prettier.format(oldText, currentPrettierConfig),
+                            newText,
                             range: {
                                 start: document.positionAt(0),
                                 end: document.positionAt(fullText.length),
@@ -72,9 +69,12 @@ function create(options = {}, getPrettierConfig = async (filePath, prettier, con
     };
 }
 exports.create = create;
-function returnObjectIfHasKeys(obj) {
-    if (Object.keys(obj || {}).length > 0) {
-        return obj;
+function matchDocument(selector, document) {
+    for (const sel of selector) {
+        if (sel === document.languageId || (typeof sel === 'object' && sel.language === document.languageId)) {
+            return true;
+        }
     }
+    return false;
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "volar-service-prettier",
-	"version": "0.0.31",
+	"version": "0.0.32",
 	"description": "Integrate Prettier into Volar",
 	"homepage": "https://github.com/volarjs/services/tree/master/packages/prettier",
 	"bugs": "https://github.com/volarjs/services/issues",
@@ -43,5 +43,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "f7005aef724767786ee9fe943fa976231cc79bf1"
+	"gitHead": "717049e7dcd5c30f451f6db8eb71eaba43f74c83"
 }