├── .gitignore
├── .github
    └── FUNDING.yml
├── test.dprint.json
├── src
    ├── lib.rs
    ├── plugin.rs
    ├── configuration.rs
    └── format.rs
├── dprint.json
├── Cargo.toml
├── test
    └── file.vue
├── LICENSE
├── README.md
└── CHANGELOG.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | Cargo.lock
3 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: malobre
2 | 


--------------------------------------------------------------------------------
/test.dprint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "incremental": true,
 3 |   "includes": ["test/*.vue"],
 4 |   "excludes": [],
 5 |   "plugins": [
 6 |     "https://plugins.dprint.dev/typescript-0.62.2.wasm",
 7 |     "./target/wasm32-unknown-unknown/release/dprint_plugin_vue.wasm"
 8 |   ]
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | mod configuration;
 2 | mod format;
 3 | mod plugin;
 4 | 
 5 | #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 6 | mod wasm {
 7 |     use crate::{configuration::Configuration, plugin::VuePluginHandler};
 8 |     use dprint_core::plugins::SyncPluginHandler;
 9 |     dprint_core::generate_plugin_code!(VuePluginHandler, VuePluginHandler::new());
10 | }
11 | 


--------------------------------------------------------------------------------
/dprint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "incremental": true,
 3 |   "includes": ["**/*.{json,md,toml}"],
 4 |   "excludes": [
 5 |     "target"
 6 |   ],
 7 |   "markdown": {
 8 |     "textWrap": "always"
 9 |   },
10 |   "plugins": [
11 |     "https://plugins.dprint.dev/json-0.14.1.wasm",
12 |     "https://plugins.dprint.dev/markdown-0.12.2.wasm",
13 |     "https://plugins.dprint.dev/toml-0.5.4.wasm"
14 |   ]
15 | }
16 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "dprint-plugin-vue"
 3 | version = "0.5.0"
 4 | edition = "2021"
 5 | license = "MIT"
 6 | 
 7 | [lib]
 8 | crate-type = ["lib", "cdylib"]
 9 | 
10 | [profile.release]
11 | opt-level = 3
12 | debug = false
13 | lto = true
14 | debug-assertions = false
15 | overflow-checks = false
16 | panic = "abort"
17 | 
18 | [dependencies]
19 | anyhow = "1.0.52"
20 | dprint-core = { version = "0.59", features = ["wasm"] }
21 | serde = { version = "1.0.136", features = ["derive"] }
22 | serde_json = "1"
23 | vue-sfc = "0.3.2"
24 | 


--------------------------------------------------------------------------------
/test/file.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |     <template>
 3 |         <template></template>
 4 |         <template></template>
 5 |     </template>
 6 |     <template></template>
 7 |     <template></template>
 8 | </template>
 9 | 
10 | <script lang="ts" setup>
11 | import { ExclamationIcon } from '@heroicons/vue/solid';
12 | import { Dialog, DialogOverlay, DialogTitle, TransitionChild, TransitionRoot } from '@headlessui/vue';
13 | import { watch } from "vue";
14 | 
15 | import type { NewQuoteRequest, QuoteRequest, QuoteRequestId, QuoteRequestPatch } from "@/resources/quoteRequests";
16 | import type { ApiError, AbortError, NetworkError } from "@/error";
17 | import { usePassport } from "@/passport";
18 | import { createQuoteRequest, retrieveQuoteRequest, updateQuoteRequest, destroyQuoteRequest } from "@/resources/quoteRequests";
19 | 
20 | </script>
21 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2022 Maël Obréjan
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # dprint-plugin-vue
 2 | 
 3 | Format Vue SFC.
 4 | 
 5 | This plugin format root-level blocks through `dprint`, meaning you will need to
 6 | install plugins for the languages contained in your Vue SFCs.
 7 | 
 8 | ## Block default language
 9 | 
10 | Unless a `lang` attribute is present:
11 | 
12 | | Block      | Default |
13 | | ---------- | ------- |
14 | | `script`   | `js`    |
15 | | `template` | `html`  |
16 | | `style`    | `css`   |
17 | 
18 | ## Usage
19 | 
20 | [Install](https://dprint.dev/install) and [setup](https://dprint.dev/setup)
21 | dprint, then:
22 | 
23 | 1. Run
24 |    ```shell
25 |    dprint config add malobre/vue
26 |    ```
27 | 2. Install plugins for the languages contained in your vue files.
28 | 3. Ensure `.vue` file extensions are matched in an `includes` pattern:
29 |    ```jsonc
30 |    {
31 |      // -- snip --
32 |      "includes": [
33 |        "**/*.vue"
34 |      ]
35 |    }
36 |    ```
37 | 4. Add a `vue` configuration property if desired:
38 |    ```jsonc
39 |    {
40 |      // -- snip --
41 |      "vue": {
42 |        // vue config goes here
43 |      }
44 |    }
45 |    ```
46 | 
47 | ## Configuration
48 | 
49 | | Key              | Default | Description                                |
50 | | ---------------- | ------- | ------------------------------------------ |
51 | | `indentTemplate` | `true`  | Indent the content of the `<template>` tag |
52 | | `indentScript`   | `false` | Indent the content of the `<script>` tag   |
53 | | `indentWidth`    | `2`     | Width of the indentation                   |
54 | | `useTabs`        | `false` | Use tabs for indentation                   |
55 | 
56 | ## Building
57 | 
58 | Run
59 | 
60 | ```shell
61 | cargo build --release --target=wasm32-unknown-unknown
62 | ```
63 | 


--------------------------------------------------------------------------------
/src/plugin.rs:
--------------------------------------------------------------------------------
 1 | use std::path::Path;
 2 | 
 3 | use anyhow::Result;
 4 | use dprint_core::configuration::ConfigKeyMap;
 5 | use dprint_core::configuration::GlobalConfiguration;
 6 | use dprint_core::configuration::ResolveConfigurationResult;
 7 | use dprint_core::plugins::PluginInfo;
 8 | use dprint_core::plugins::SyncPluginHandler;
 9 | 
10 | use crate::configuration::Configuration;
11 | 
12 | pub struct VuePluginHandler;
13 | 
14 | impl VuePluginHandler {
15 |     #[allow(dead_code)]
16 |     pub const fn new() -> Self {
17 |         VuePluginHandler
18 |     }
19 | }
20 | 
21 | impl SyncPluginHandler<Configuration> for VuePluginHandler {
22 |     fn plugin_info(&mut self) -> PluginInfo {
23 |         PluginInfo {
24 |             name: String::from(env!("CARGO_PKG_NAME")),
25 |             version: String::from(env!("CARGO_PKG_VERSION")),
26 |             config_key: String::from("vue"),
27 |             file_extensions: vec![String::from("vue")],
28 |             file_names: vec![],
29 |             help_url: String::from("https://github.com/malobre/dprint-plugin-vue"),
30 |             config_schema_url: String::new(),
31 |             update_url: Some(String::from(
32 |                 "https://plugins.dprint.dev/malobre/vue/latest.json",
33 |             )),
34 |         }
35 |     }
36 | 
37 |     fn license_text(&mut self) -> String {
38 |         String::from(include_str!("../LICENSE"))
39 |     }
40 | 
41 |     fn resolve_config(
42 |         &mut self,
43 |         config: ConfigKeyMap,
44 |         global_config: &GlobalConfiguration,
45 |     ) -> ResolveConfigurationResult<Configuration> {
46 |         Configuration::resolve(config, global_config)
47 |     }
48 | 
49 |     fn format(
50 |         &mut self,
51 |         file_path: &Path,
52 |         file_text: &str,
53 |         config: &Configuration,
54 |         format_with_host: impl FnMut(&Path, String, &ConfigKeyMap) -> Result<Option<String>>,
55 |     ) -> Result<Option<String>> {
56 |         crate::format::format(file_path, file_text, config, format_with_host).map(Some)
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/configuration.rs:
--------------------------------------------------------------------------------
 1 | use dprint_core::configuration::get_unknown_property_diagnostics;
 2 | use dprint_core::configuration::get_value;
 3 | use dprint_core::configuration::ConfigKeyMap;
 4 | use dprint_core::configuration::GlobalConfiguration;
 5 | use dprint_core::configuration::ResolveConfigurationResult;
 6 | use dprint_core::configuration::RECOMMENDED_GLOBAL_CONFIGURATION;
 7 | use serde::Serialize;
 8 | 
 9 | #[derive(Debug, Clone, Copy, Serialize)]
10 | #[serde(rename_all = "camelCase")]
11 | pub struct Configuration {
12 |     pub indent_template: bool,
13 |     pub indent_script: bool,
14 |     pub use_tabs: bool,
15 |     pub indent_width: u8,
16 | }
17 | 
18 | impl Default for Configuration {
19 |     fn default() -> Self {
20 |         Self {
21 |             indent_template: true,
22 |             indent_script: false,
23 |             use_tabs: RECOMMENDED_GLOBAL_CONFIGURATION.use_tabs,
24 |             indent_width: RECOMMENDED_GLOBAL_CONFIGURATION.indent_width,
25 |         }
26 |     }
27 | }
28 | 
29 | impl Configuration {
30 |     pub(crate) fn resolve(
31 |         mut config: ConfigKeyMap,
32 |         global_config: &GlobalConfiguration,
33 |     ) -> ResolveConfigurationResult<Configuration> {
34 |         let mut diagnostics = Vec::new();
35 | 
36 |         let resolved_config = Configuration {
37 |             indent_template: get_value(&mut config, "indentTemplate", true, &mut diagnostics),
38 |             indent_script: get_value(&mut config, "indentScript", false, &mut diagnostics),
39 |             use_tabs: get_value(
40 |                 &mut config,
41 |                 "useTabs",
42 |                 global_config
43 |                     .use_tabs
44 |                     .unwrap_or(RECOMMENDED_GLOBAL_CONFIGURATION.use_tabs),
45 |                 &mut diagnostics,
46 |             ),
47 |             indent_width: get_value(
48 |                 &mut config,
49 |                 "indentWidth",
50 |                 global_config
51 |                     .indent_width
52 |                     .unwrap_or(RECOMMENDED_GLOBAL_CONFIGURATION.indent_width),
53 |                 &mut diagnostics,
54 |             ),
55 |         };
56 | 
57 |         diagnostics.extend(get_unknown_property_diagnostics(config));
58 | 
59 |         ResolveConfigurationResult {
60 |             config: resolved_config,
61 |             diagnostics,
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file.
  4 | 
  5 | The format is based on [Keep a Changelog], and this project adheres to
  6 | [Semantic Versioning].
  7 | 
  8 | ## [Unreleased]
  9 | 
 10 | ## [0.5.0] - 2022-11-07
 11 | 
 12 | ### Changed
 13 | 
 14 | - Always print a newline at EOF.
 15 | 
 16 | ## [0.4.2] - 2022-03-21
 17 | 
 18 | ### Fixed
 19 | 
 20 | - Empty lines are now correctly handled when computing template indentation.
 21 | 
 22 | ## [0.4.1] - 2022-02-14
 23 | 
 24 | ## [0.4.0] - 2022-02-10
 25 | 
 26 | ### Changed
 27 | 
 28 | - Block indentation width is now computed and adjusted according to the configuration.
 29 | 
 30 | ### Fixed
 31 | 
 32 | - `indentTemplate` now works correctly when the content couldn't be
 33 |   formatted through dprint.
 34 | 
 35 | ## [0.3.2] - 2022-02-03
 36 | 
 37 | ### Added
 38 | 
 39 | - Plugin can now be updated through `dprint config update`.
 40 | 
 41 | ## [0.3.1] - 2022-01-29
 42 | 
 43 | ### Fixed
 44 | 
 45 | - Fixed missing indentation before block content when using `indentTemplate`.
 46 | 
 47 | ## [0.3.0] - 2022-01-27
 48 | 
 49 | ### Added
 50 | 
 51 | - Added configuration:
 52 | 
 53 |   | Key              | Default | Description                                |
 54 |   | ---------------- | ------- | ------------------------------------------ |
 55 |   | `indentTemplate` | `true`  | Indent the content of the `<template>` tag |
 56 |   | `indentWidth`    | `2`     | Width of the indentation                   |
 57 |   | `useTabs`        | `false` | Use tabs for indentation                   |
 58 | 
 59 | ### Changed
 60 | 
 61 | - Formatted content is now end-trimmed.
 62 | - Block tag names are now compared case-insensitively.
 63 | - Block content is passed to dprint with `file.vue.{lang}` as its filename.
 64 | 
 65 | ## [0.2.0] - 2022-01-25
 66 | 
 67 | ### Added
 68 | 
 69 | - Some documentation.
 70 | - Basic README.
 71 | - Latest download URL in the README.
 72 | - CHANGELOG.
 73 | 
 74 | ### Removed
 75 | 
 76 | - Removed `Configuration`.
 77 | 
 78 | ## [0.1.1] - 2022-01-25
 79 | 
 80 | ### Fixed
 81 | 
 82 | - Fix nested tags parsing (#1).
 83 | 
 84 | ## [0.1.0] - 2022-01-25
 85 | 
 86 | ### Added
 87 | 
 88 | - Initial code
 89 | 
 90 | [unreleased]: https://github.com/malobre/dprint-plugin-vue/compare/v0.5.0...HEAD
 91 | [0.5.0]: https://github.com/malobre/dprint-plugin-vue/compare/v0.4.2...v0.5.0
 92 | [0.4.2]: https://github.com/malobre/dprint-plugin-vue/compare/v0.4.1...v0.4.2
 93 | [0.4.1]: https://github.com/malobre/dprint-plugin-vue/compare/v0.4.0...v0.4.1
 94 | [0.4.0]: https://github.com/malobre/dprint-plugin-vue/compare/v0.3.2...v0.4.0
 95 | [0.3.2]: https://github.com/malobre/dprint-plugin-vue/compare/v0.3.1...v0.3.2
 96 | [0.3.1]: https://github.com/malobre/dprint-plugin-vue/compare/v0.3.0...v0.3.1
 97 | [0.3.0]: https://github.com/malobre/dprint-plugin-vue/compare/v0.2.0...v0.3.0
 98 | [0.2.0]: https://github.com/malobre/dprint-plugin-vue/compare/v0.1.1...v0.2.0
 99 | [0.1.1]: https://github.com/malobre/dprint-plugin-vue/compare/v0.1.0...v0.1.1
100 | [0.1.0]: https://github.com/malobre/dprint-plugin-vue/releases/tag/v0.1.0
101 | [Semantic Versioning]: https://semver.org/spec/v2.0.0.html
102 | [Keep a Changelog]: https://keepachangelog.com/en/1.0.0/index.html
103 | 


--------------------------------------------------------------------------------
/src/format.rs:
--------------------------------------------------------------------------------
  1 | use std::borrow::Cow;
  2 | use std::cmp::Ordering;
  3 | use std::fmt::Write;
  4 | use std::iter::repeat;
  5 | use std::path::Path;
  6 | use std::path::PathBuf;
  7 | 
  8 | use anyhow::Result;
  9 | use dprint_core::configuration::ConfigKeyMap;
 10 | 
 11 | use crate::configuration::Configuration;
 12 | use vue_sfc::{Block, Section};
 13 | 
 14 | fn default_lang(block: &str) -> Option<&'static str> {
 15 |     match block {
 16 |         "template" => Some("html"),
 17 |         "script" => Some("js"),
 18 |         "style" => Some("css"),
 19 |         _ => None,
 20 |     }
 21 | }
 22 | 
 23 | pub fn format(
 24 |     _path: &Path,
 25 |     content: &str,
 26 |     config: &Configuration,
 27 |     mut format_with_host: impl FnMut(&Path, String, &ConfigKeyMap) -> Result<Option<String>>,
 28 | ) -> Result<String> {
 29 |     let mut buffer = String::new();
 30 | 
 31 |     let mut sections = vue_sfc::parse(content)?.into_iter().peekable();
 32 | 
 33 |     while let Some(section) = sections.next() {
 34 |         if let Section::Block(block) = section {
 35 |             writeln!(
 36 |                 &mut buffer,
 37 |                 "{}",
 38 |                 format_block(block, config, &mut format_with_host)?
 39 |             )?;
 40 |         } else {
 41 |             writeln!(&mut buffer, "{}", section)?;
 42 |         }
 43 | 
 44 |         if sections.peek().is_some() {
 45 |             writeln!(&mut buffer)?;
 46 |         }
 47 |     }
 48 | 
 49 |     Ok(buffer)
 50 | }
 51 | 
 52 | fn format_block<'a>(
 53 |     block: Block<'a>,
 54 |     config: &Configuration,
 55 |     format_with_host: &mut impl FnMut(&Path, String, &ConfigKeyMap) -> Result<Option<String>>,
 56 | ) -> Result<Block<'a>> {
 57 |     let lang = block
 58 |         .attributes
 59 |         .iter()
 60 |         .find_map(|(name, value)| match (name.as_str(), value) {
 61 |             ("lang", Some(value)) => Some(value.as_str()),
 62 |             _ => None,
 63 |         })
 64 |         .or_else(|| default_lang(&block.name));
 65 | 
 66 |     if let Some(lang) = lang {
 67 |         let pretty = {
 68 |             let file_path = PathBuf::from(format!("file.vue.{lang}"));
 69 |             let Some(pretty) =
 70 |                 format_with_host(&file_path, block.content.to_string(), &ConfigKeyMap::new())?
 71 |             else {
 72 |                 return Ok(block);
 73 |             };
 74 | 
 75 |             let indent_width = pretty
 76 |                 .lines()
 77 |                 .filter_map(|line| {
 78 |                     let trimed_line = line.trim_start();
 79 |                     if trimed_line.is_empty() {
 80 |                         None
 81 |                     } else {
 82 |                         Some(line.len() - trimed_line.len())
 83 |                     }
 84 |                 })
 85 |                 .min()
 86 |                 .unwrap_or(0);
 87 | 
 88 |             let desired_indent_width =
 89 |                 if block.name.as_str() == "template" && config.indent_template {
 90 |                     usize::from(config.indent_width)
 91 |                 } else if block.name.as_str() == "script" && config.indent_script {
 92 |                     usize::from(config.indent_width)
 93 |                 } else {
 94 |                     0
 95 |                 };
 96 | 
 97 |             match indent_width.cmp(&desired_indent_width) {
 98 |                 Ordering::Equal => pretty,
 99 |                 Ordering::Less => {
100 |                     let delta = desired_indent_width - indent_width;
101 | 
102 |                     let mut buffer =
103 |                         String::with_capacity(pretty.len() + pretty.lines().count() * delta);
104 | 
105 |                     for line in pretty.lines() {
106 |                         buffer.extend(repeat(if config.use_tabs { '\t' } else { ' ' }).take(delta));
107 |                         buffer.push_str(line);
108 |                         buffer.push('\n');
109 |                     }
110 | 
111 |                     buffer
112 |                 }
113 |                 Ordering::Greater => {
114 |                     let delta = indent_width - desired_indent_width;
115 | 
116 |                     let mut buffer =
117 |                         String::with_capacity(pretty.len() - pretty.lines().count() * delta);
118 | 
119 |                     for line in pretty.lines() {
120 |                         buffer.push_str(&line[delta..]);
121 |                         buffer.push('\n');
122 |                     }
123 | 
124 |                     buffer
125 |                 }
126 |             }
127 |         };
128 | 
129 |         Ok(Block {
130 |             name: block.name,
131 |             attributes: block.attributes,
132 |             content: Cow::Owned(pretty),
133 |         })
134 |     } else {
135 |         Ok(block)
136 |     }
137 | }
138 | 
139 | #[cfg(test)]
140 | mod test {
141 |     use std::path::{Path, PathBuf};
142 | 
143 |     use crate::configuration::Configuration;
144 | 
145 |     use super::format;
146 | 
147 |     #[test]
148 |     fn test_format_with_host() {
149 |         let config = Configuration {
150 |             indent_template: true,
151 |             indent_script: true,
152 |             use_tabs: false,
153 |             indent_width: 2,
154 |         };
155 | 
156 |         let raw = "<template></template><script></script>";
157 | 
158 |         let mut buffer = Vec::new();
159 | 
160 |         format(Path::new("file.vue"), raw, &config, |path, content, _| {
161 |             buffer.push((path.to_owned(), content.clone()));
162 |             Ok(Some(content))
163 |         })
164 |         .unwrap();
165 | 
166 |         assert_eq!(buffer[0], (PathBuf::from("file.vue.html"), String::new()));
167 | 
168 |         assert_eq!(buffer[1], (PathBuf::from("file.vue.js"), String::new()));
169 |     }
170 | 
171 |     #[test]
172 |     fn test_indent_template() {
173 |         let config = Configuration {
174 |             indent_template: true,
175 |             indent_script: true,
176 |             use_tabs: false,
177 |             indent_width: 2,
178 |         };
179 | 
180 |         assert_eq!(
181 |             format(
182 |                 Path::new("file.vue"),
183 |                 "<template><div></div></template>",
184 |                 &config,
185 |                 |_, raw, _| Ok(Some(raw))
186 |             )
187 |             .unwrap(),
188 |             "<template>\n  <div></div>\n</template>\n"
189 |         );
190 | 
191 |         assert_eq!(
192 |             format(
193 |                 Path::new("file.vue"),
194 |                 "<template>\n  <div></div>\n\n  <div></div>\n</template>",
195 |                 &config,
196 |                 |_, raw, _| Ok(Some(raw))
197 |             )
198 |             .unwrap(),
199 |             "<template>\n  <div></div>\n\n  <div></div>\n</template>\n"
200 |         );
201 |     }
202 | }
203 | 


--------------------------------------------------------------------------------