feat: add "quoteProps" configuration (#330)

Author: cspotcode

Diff for: deployment/schema.json

@@ -60,6 +60,18 @@
         "description": "Prefers using single quotes except in scenarios where the string contains more single quotes than double quotes."
       }]
     },
+    "quoteProps": {
+      "description": "Change when properties in objects are quoted.",
+      "type": "string",
+      "default": "preserve",
+      "oneOf": [{
+        "const": "preserve",
+        "description": "Preserve quotes around property names."
+      }, {
+        "const": "asNeeded",
+        "description": "Remove unnecessary quotes around property names."
+      }]
+    },
     "jsx.multiLineParens": {
       "description": "Surrounds the top-most JSX element or fragment in parentheses when it spans multiple lines.",
       "type": "string",
@@ -679,6 +691,9 @@
     "quoteStyle": {
       "$ref": "#/definitions/quoteStyle"
     },
+    "quoteProps": {
+      "$ref": "#/definitions/quoteProps"
+    },
     "newLineKind": {
       "$ref": "#/definitions/newLineKind"
     },

Diff for: src/configuration/resolve_config.rs

@@ -45,6 +45,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
   let space_surrounding_properties = get_value(&mut config, "spaceSurroundingProperties", true, &mut diagnostics);
   let type_literal_separator_kind = get_value(&mut config, "typeLiteral.separatorKind", SemiColonOrComma::SemiColon, &mut diagnostics);
   let quote_style = get_value(&mut config, "quoteStyle", QuoteStyle::AlwaysDouble, &mut diagnostics);
+  let quote_props = get_value(&mut config, "quoteProps", QuoteProps::Preserve, &mut diagnostics);
 
   let resolved_config = Configuration {
     line_width: get_value(
@@ -72,6 +73,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
       &mut diagnostics,
     ),
     quote_style,
+    quote_props,
     semi_colons,
     /* situational */
     arrow_function_use_parentheses: get_value(&mut config, "arrowFunction.useParentheses", UseParentheses::Maintain, &mut diagnostics),

Diff for: src/configuration/types.rs

@@ -206,6 +206,23 @@ pub enum JsxQuoteStyle {
 
 generate_str_to_from![JsxQuoteStyle, [PreferDouble, "preferDouble"], [PreferSingle, "preferSingle"]];
 
+/// How to decide to use single or double quotes.
+#[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum QuoteProps {
+  /// Preserve quotes around property names.
+  Preserve,
+  /// Remove unnecessary quotes around property names.
+  AsNeeded,
+}
+
+generate_str_to_from![
+  QuoteProps,
+  [Preserve, "preserve"],
+  [AsNeeded, "asNeeded"]
+];
+
+
 /// Whether to surround a JSX element or fragment with parentheses
 /// when it's the top JSX node and it spans multiple lines.
 #[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
@@ -261,6 +278,7 @@ pub struct Configuration {
   pub use_tabs: bool,
   pub new_line_kind: NewLineKind,
   pub quote_style: QuoteStyle,
+  pub quote_props: QuoteProps,
   pub semi_colons: SemiColons,
   /* situational */
   #[serde(rename = "arrowFunction.useParentheses")]

Diff for: src/generation/generate.rs

@@ -1,5 +1,6 @@
 use deno_ast::swc::common::comments::{Comment, CommentKind};
 use deno_ast::swc::common::{BytePos, Span, Spanned};
+use deno_ast::swc::parser::lexer::util::CharExt;
 use deno_ast::swc::parser::token::{Token, TokenAndSpan};
 use deno_ast::view::*;
 use deno_ast::MediaType;
@@ -3486,10 +3487,48 @@ fn gen_string_literal<'a>(node: &'a Str, context: &mut Context<'a>) -> PrintItem
   return gen_from_raw_string(&get_string_literal_text(
     get_string_value(&node, context),
     node.parent().is::<JSXAttr>(),
+    context.config.quote_props == QuoteProps::AsNeeded && is_property_name(&node),
     context,
   ));
 
-  fn get_string_literal_text(string_value: String, is_jsx_attribute: bool, context: &mut Context) -> String {
+  fn is_property_name(node: &Str) -> bool {
+    match node.parent() {
+      Node::KeyValueProp(parent) => match_key_prop_name(parent.key),
+      Node::GetterProp(parent) => match_key_prop_name(parent.key),
+      Node::SetterProp(parent) => match_key_prop_name(parent.key),
+      Node::MethodProp(parent) => match_key_prop_name(parent.key),
+      // Do not match class properties Node::ClassProp
+      // With `--strictPropertyInitialization`, TS treats properties with quoted names differently than unquoted ones.
+      // See https://github.com/microsoft/TypeScript/pull/20075
+      // See prettier implementation https://github.com/prettier/prettier/blob/514046b3c70e6477cb69b4d36871d0d4c8c5e415/src/language-js/utils.js#L671-L716
+      Node::ClassMethod(parent) => match_key_prop_name(parent.key),
+      Node::TsPropertySignature(parent) => match_key_expr(parent.key),
+      Node::TsGetterSignature(parent) => match_key_expr(parent.key),
+      Node::TsSetterSignature(parent) => match_key_expr(parent.key),
+      Node::TsMethodSignature(parent) => match_key_expr(parent.key),
+      _ => false
+    }
+  }
+
+  fn match_key_expr(key: Expr) -> bool {
+    match key {
+        Expr::Lit(Lit::Str(_str)) => true,
+        Expr::Tpl(_tpl) => true,
+        _ => false
+    }
+  }
+  fn match_key_prop_name(key: PropName) -> bool {
+    match key {
+      PropName::Str(_str) => true,
+      _ => false
+    }
+  }
+  
+
+  fn get_string_literal_text(string_value: String, is_jsx_attribute: bool, should_remove_quotes_if_identifier: bool, context: &mut Context) -> String {
+    if should_remove_quotes_if_identifier && is_valid_identifier(&string_value) {
+      return string_value
+    }
     return if is_jsx_attribute {
       // JSX attributes cannot contain escaped quotes so regardless of
       // configuration, allow changing the quote style to single or
@@ -3507,6 +3546,16 @@ fn gen_string_literal<'a>(node: &'a Str, context: &mut Context<'a>) -> PrintItem
       }
     };
 
+    fn is_valid_identifier(string_value: &str) -> bool {
+      if string_value.len() == 0 { return false }
+      for (i, c) in string_value.chars().enumerate() {
+        if (i == 0 && !c.is_ident_start()) || !c.is_ident_part() {
+          return false
+        }
+      };
+      true
+    }
+
     fn handle_prefer_double(string_value: String) -> String {
       if double_to_single(&string_value) <= 0 {
         format_with_double(string_value)

Diff for: tests/specs/literals/StringLiteral/StringLiteral_QuoteProps_AsNeeded.txt

@@ -0,0 +1,142 @@
+~~ quoteProps: asNeeded ~~
+== should preserve quotes when necessary ==
+const objectLiteral = {
+    "foo bar": true,
+    "foo\nbar": true,
+    "1foo": true,
+    "💩": true,
+    "a💩": true,
+    "c\d": true,
+    "1": true,
+    "1foo"() {},
+    get "2foo"() {},
+    set "2foo"(v) {},
+    async "3foo"() {},
+};
+class Class {
+    "1foo"() {}
+    get "1foo"() {}
+    set "1foo"() {}
+    async "3foo"() {}
+    "4foo": string;
+    "1" = true;
+}
+interface Interface {
+    "1foo": string;
+    "2foo"(): string;
+    get "3foo"(): string;
+    set "3foo"(v: string);
+}
+type Type = {
+    "1foo": string;
+    "2foo"(): string;
+    get "3foo"(): string;
+    set "3foo"(v: string);
+};
+
+[expect]
+const objectLiteral = {
+    "foo bar": true,
+    "foo\nbar": true,
+    "1foo": true,
+    "💩": true,
+    "a💩": true,
+    "c\d": true,
+    "1": true,
+    "1foo"() {},
+    get "2foo"() {},
+    set "2foo"(v) {},
+    async "3foo"() {},
+};
+class Class {
+    "1foo"() {}
+    get "1foo"() {}
+    set "1foo"() {}
+    async "3foo"() {}
+    "4foo": string;
+    "1" = true;
+}
+interface Interface {
+    "1foo": string;
+    "2foo"(): string;
+    get "3foo"(): string;
+    set "3foo"(v: string);
+}
+type Type = {
+    "1foo": string;
+    "2foo"(): string;
+    get "3foo"(): string;
+    set "3foo"(v: string);
+};
+
+== should remove quotes when unnecessary ==
+const objectLiteral = {
+    "foo": true,
+    "$": true,
+    "_": true,
+    "_1": true,
+    'foo': true,
+    '$': true,
+    '_': true,
+    '_1': true,
+    'é': true,
+    "foo"() {},
+    get "foo2"() {},
+    set "foo2"(v) {},
+    async "foo3"() {},
+};
+class Class {
+    "foo"() {}
+    get "foo2"() {}
+    set "foo2"() {}
+    async "foo3"() {}
+    "foo4": string;
+}
+interface Interface {
+    "foo": string;
+    "foo2"(): string;
+    get "foo3"(): string;
+    set "foo3"(v: string);
+}
+type Type = {
+    "foo": string;
+    "foo2"(): string;
+    get "foo3"(): string;
+    set "foo3"(v: string);
+};
+
+[expect]
+const objectLiteral = {
+    foo: true,
+    $: true,
+    _: true,
+    _1: true,
+    foo: true,
+    $: true,
+    _: true,
+    _1: true,
+    é: true,
+    foo() {},
+    get foo2() {},
+    set foo2(v) {},
+    async foo3() {},
+};
+class Class {
+    foo() {}
+    get foo2() {}
+    set foo2() {}
+    async foo3() {}
+    "foo4": string;
+}
+interface Interface {
+    foo: string;
+    foo2(): string;
+    get foo3(): string;
+    set foo3(v: string);
+}
+type Type = {
+    foo: string;
+    foo2(): string;
+    get foo3(): string;
+    set foo3(v: string);
+};