style: apply prettier

Author: azu

.githooks/pre-commit

@@ -0,0 +1,2 @@
+#!/bin/sh
+npx --no-install lint-staged

.yarn/releases/yarn-1.22.4.js

@@ -5,19 +5,32 @@
     "website"
   ],
   "devDependencies": {
-    "lerna": "^7.1.4"
+    "lerna": "^7.1.4",
+    "prettier": "^3.2.5"
   },
   "scripts": {
     "build": "lerna run build",
     "test": "lerna run test",
-    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
     "versionup": "lerna version --conventional-commits",
     "versionup:patch": "lerna version patch --conventional-commits",
     "versionup:minor": "lerna version minor --conventional-commits",
     "versionup:major": "lerna version major --conventional-commits",
-    "release": "lerna publish from-package"
+    "release": "lerna publish from-package",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
+    "prepare": "git config --local core.hooksPath .githooks"
   },
   "keywords": [
     "textlintrule"
-  ]
+  ],
+  "prettier": {
+    "singleQuote": false,
+    "printWidth": 120,
+    "tabWidth": 4,
+    "trailingComma": "none"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,css}": [
+      "prettier --write"
+    ]
+  }
 }

package.json

@@ -4,28 +4,30 @@
  カタカナ語間のスペースの有無
  中黒または半角スペースを用いてカタカナ語を区切ります。
  */
-import {RuleHelper} from "textlint-rule-helper";
-import {matchCaptureGroupAll} from "match-index";
-module.exports = function(context) {
-    const {Syntax, RuleError, report, getSource} = context;
+import { RuleHelper } from "textlint-rule-helper";
+import { matchCaptureGroupAll } from "match-index";
+module.exports = function (context) {
+    const { Syntax, RuleError, report, getSource } = context;
     const helper = new RuleHelper();
     return {
-        [Syntax.Str](node){
+        [Syntax.Str](node) {
             if (!helper.isPlainStrNode(node)) {
                 return;
             }
             const text = getSource(node);
             // カタカナ(カタカナ以外)カタカナ のパターンを取り出す
-            matchCaptureGroupAll(text, /[ァ-ヶー]([^[ァ-ヶー])[ァ-ヶー]/).forEach(match => {
+            matchCaptureGroupAll(text, /[ァ-ヶー]([^[ァ-ヶー])[ァ-ヶー]/).forEach((match) => {
                 // カタカナの間を全角スペースでは区切らない
-                const {text} = match;
+                const { text } = match;
                 if (text === "　") {
-                    report(node, new RuleError("カタカナ語間は中黒（・）または半角スペースを用いてカタカナ語を区切ります", {
-                        index: match.index
-                    }));
+                    report(
+                        node,
+                        new RuleError("カタカナ語間は中黒（・）または半角スペースを用いてカタカナ語を区切ります", {
+                            index: match.index
+                        })
+                    );
                 }
             });
-
         }
     };
 };

packages/textlint-rule-ja-nakaguro-or-halfwidth-space-between-katakana/src/index.js

@@ -7,7 +7,7 @@ tester.run("カタカナ語間のスペースの有無", rule, {
     valid: [
         "カタカナ・カタカナ",
         "カタカナ カタカナ",
-        "カタカナ、カタカナ",// 例外としてしょうがない気がする
+        "カタカナ、カタカナ", // 例外としてしょうがない気がする
         "あいう　えお",
         "インターフェース ブラウザ"
     ],

packages/textlint-rule-ja-nakaguro-or-halfwidth-space-between-katakana/test/index-test.js

@@ -4,46 +4,50 @@
  かっこ類と隣接する文字の間のスペースの有無
  かっこの外側、内側ともにスペースを入れません。
  */
-import {RuleHelper} from "textlint-rule-helper";
-import {matchCaptureGroupAll} from "match-index";
+import { RuleHelper } from "textlint-rule-helper";
+import { matchCaptureGroupAll } from "match-index";
 
-const brackets = [
-    "\\[", "\\]", "（", "）", "［", "］", "「", "」", "『", "』"
-];
+const brackets = ["\\[", "\\]", "（", "）", "［", "］", "「", "」", "『", "』"];
 
-const leftBrackets = brackets.map(bracket => {
-    return new RegExp("\([ 　]\)" + bracket, "g");
+const leftBrackets = brackets.map((bracket) => {
+    return new RegExp("([ 　])" + bracket, "g");
 });
-const rightBrackets = brackets.map(bracket => {
-    return new RegExp(bracket + "\([ 　])", "g");
+const rightBrackets = brackets.map((bracket) => {
+    return new RegExp(bracket + "([ 　])", "g");
 });
 function reporter(context) {
-    const {Syntax, RuleError, report, fixer, getSource} = context;
+    const { Syntax, RuleError, report, fixer, getSource } = context;
     const helper = new RuleHelper();
     return {
-        [Syntax.Str](node){
+        [Syntax.Str](node) {
             if (!helper.isPlainStrNode(node)) {
                 return;
             }
             const text = getSource(node);
             // 左にスペース
-            leftBrackets.forEach(pattern => {
-                matchCaptureGroupAll(text, pattern).forEach(match => {
-                    const {index} = match;
-                    report(node, new RuleError("かっこの外側、内側ともにスペースを入れません。", {
-                        index: index,
-                        fix: fixer.replaceTextRange([index, index + 1], "")
-                    }));
+            leftBrackets.forEach((pattern) => {
+                matchCaptureGroupAll(text, pattern).forEach((match) => {
+                    const { index } = match;
+                    report(
+                        node,
+                        new RuleError("かっこの外側、内側ともにスペースを入れません。", {
+                            index: index,
+                            fix: fixer.replaceTextRange([index, index + 1], "")
+                        })
+                    );
                 });
             });
             // 右にスペース
-            rightBrackets.forEach(pattern => {
-                matchCaptureGroupAll(text, pattern).forEach(match => {
-                    const {index, text} = match;
-                    report(node, new RuleError("かっこの外側、内側ともにスペースを入れません。", {
-                        index: index,
-                        fix: fixer.replaceTextRange([index, index + 1], "")
-                    }));
+            rightBrackets.forEach((pattern) => {
+                matchCaptureGroupAll(text, pattern).forEach((match) => {
+                    const { index, text } = match;
+                    report(
+                        node,
+                        new RuleError("かっこの外側、内側ともにスペースを入れません。", {
+                            index: index,
+                            fix: fixer.replaceTextRange([index, index + 1], "")
+                        })
+                    );
                 });
             });
         }

packages/textlint-rule-ja-no-space-around-parentheses/src/index.js

@@ -14,17 +14,13 @@ tester.run("かっこ類と隣接する文字の間のスペースの有無", ru
 というルールがあるだけとも言えます。
 `,
         "[テスト 「文章」 です](https://example)", // ignore Link
-        "[テスト 「文章」 です][]" +
-        "\n\n" +
-        "[テスト 「文章」 です]: https://example.com" // ignore ReferenceDef
+        "[テスト 「文章」 です][]" + "\n\n" + "[テスト 「文章」 です]: https://example.com" // ignore ReferenceDef
     ],
     invalid: [
         {
             text: "「 ダメ」",
             output: "「ダメ」",
-            errors: [
-                {message: "かっこの外側、内側ともにスペースを入れません。"}
-            ]
+            errors: [{ message: "かっこの外側、内側ともにスペースを入れません。" }]
         },
         {
             text: "これは 「ダメ」です",
@@ -36,7 +32,8 @@ tester.run("かっこ類と隣接する文字の間のスペースの有無", ru
                     column: 4
                 }
             ]
-        }, {
+        },
+        {
             text: `TEST
 
 - TODO

packages/textlint-rule-ja-no-space-around-parentheses/test/index-test.js

@@ -5,36 +5,40 @@
  全角文字どうしの間にスペースを入れません。
  ただしカタカナ複合語の場合を除きます。
  */
-import {RuleHelper} from "textlint-rule-helper";
-import {matchAll} from "match-index";
+import { RuleHelper } from "textlint-rule-helper";
+import { matchAll } from "match-index";
 import regx from "regx";
 const rx = regx("g");
-const japaneseRegExp = /(?:[々〇〻\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]|[\uD840-\uD87F][\uDC00-\uDFFF]|[ぁ-んァ-ヶ])/;
+const japaneseRegExp =
+    /(?:[々〇〻\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]|[\uD840-\uD87F][\uDC00-\uDFFF]|[ぁ-んァ-ヶ])/;
 
 function reporter(context) {
-    const {Syntax, RuleError, report, fixer, getSource} = context;
+    const { Syntax, RuleError, report, fixer, getSource } = context;
     const helper = new RuleHelper();
     return {
-        [Syntax.Str](node){
+        [Syntax.Str](node) {
             if (!helper.isPlainStrNode(node)) {
                 return;
             }
             const text = getSource(node);
             // 全角同士の間は半角スペースを入れない
             const matchReg = rx`${japaneseRegExp}( )${japaneseRegExp}`;
             const katakakana = /[ァ-ヶ]( )[ァ-ヶ]/;
-            matchAll(text, matchReg).forEach(match => {
-                const {input, captureGroups} = match;
+            matchAll(text, matchReg).forEach((match) => {
+                const { input, captureGroups } = match;
                 // ただしカタカナ複合語の場合を除きます。
                 if (katakakana.test(input)) {
                     return;
                 }
-                captureGroups.forEach(captureGroup => {
+                captureGroups.forEach((captureGroup) => {
                     const index = captureGroup.index;
-                    report(node, new RuleError("原則として、全角文字どうしの間にスペースを入れません。", {
-                        index: index,
-                        fix: fixer.replaceTextRange([index, index + 1], "")
-                    }));
+                    report(
+                        node,
+                        new RuleError("原則として、全角文字どうしの間にスペースを入れません。", {
+                            index: index,
+                            fix: fixer.replaceTextRange([index, index + 1], "")
+                        })
+                    );
                 });
             });
         }

packages/textlint-rule-ja-no-space-between-full-width/src/index.js

@@ -8,7 +8,7 @@ tester.run("全角文字どうし", rule, {
         "これは正解",
         "This is 大丈夫",
         "This is a pen.",
-        "ユーザー インターフェース"//カタカナは例外
+        "ユーザー インターフェース" //カタカナは例外
     ],
     invalid: [
         {

packages/textlint-rule-ja-no-space-between-full-width/test/index-test.js

@@ -5,26 +5,29 @@
  文末に感嘆符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。
  文中に感嘆符を使用する場合はスペースを挿入しません。
  */
-import {RuleHelper} from "textlint-rule-helper";
-import {matchCaptureGroupAll} from "match-index";
+import { RuleHelper } from "textlint-rule-helper";
+import { matchCaptureGroupAll } from "match-index";
 function reporter(context) {
-    const {Syntax, RuleError, report, fixer, getSource} = context;
+    const { Syntax, RuleError, report, fixer, getSource } = context;
     const helper = new RuleHelper();
     return {
-        [Syntax.Str](node){
+        [Syntax.Str](node) {
             if (!helper.isPlainStrNode(node)) {
                 return;
             }
             let text = getSource(node);
             // ！の後ろは全角スペースが推奨
             // 半角スペースである場合
             const matchAfter = /！( )[^\n]/;
-            matchCaptureGroupAll(text, matchAfter).forEach(match => {
-                const {index} = match;
-                return report(node, new RuleError("文末に感嘆符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。", {
-                    index: index,
-                    fix: fixer.replaceTextRange([index, index + 1], "　")
-                }));
+            matchCaptureGroupAll(text, matchAfter).forEach((match) => {
+                const { index } = match;
+                return report(
+                    node,
+                    new RuleError("文末に感嘆符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。", {
+                        index: index,
+                        fix: fixer.replaceTextRange([index, index + 1], "　")
+                    })
+                );
             });
         }
     };

packages/textlint-rule-ja-space-after-exclamation/src/index.js

@@ -8,7 +8,7 @@ tester.run("感嘆符(!)", rule, {
         "【原文】Just plug it in, and coffee is ready in three minutes!",
         "【訳文】プラグを差し込めば、3 分でコーヒーができます。",
         "警告！",
-        "驚きの速さ！　これが新製品のキャッチコピーでした。"// 文末感嘆符+全角スペース
+        "驚きの速さ！　これが新製品のキャッチコピーでした。" // 文末感嘆符+全角スペース
     ],
     invalid: [
         {

packages/textlint-rule-ja-space-after-exclamation/test/index-test.js

@@ -5,26 +5,29 @@
  文末に疑問符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。
  文中に疑問符を使用する場合はスペースを挿入しません。
  */
-import {RuleHelper} from "textlint-rule-helper";
-import {matchCaptureGroupAll} from "match-index";
+import { RuleHelper } from "textlint-rule-helper";
+import { matchCaptureGroupAll } from "match-index";
 function reporter(context) {
-    const {Syntax, RuleError, report, fixer, getSource} = context;
+    const { Syntax, RuleError, report, fixer, getSource } = context;
     const helper = new RuleHelper();
     return {
-        [Syntax.Str](node){
+        [Syntax.Str](node) {
             if (!helper.isPlainStrNode(node)) {
                 return;
             }
             let text = getSource(node);
             // ？の後ろは全角スペースが推奨
             // 半角スペースである場合はエラーとする
             const matchAfter = /？( )[^\n]/;
-            matchCaptureGroupAll(text, matchAfter).forEach(match => {
-                const {index} = match;
-                return report(node, new RuleError("文末に疑問符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。", {
-                    index: index,
-                    fix: fixer.replaceTextRange([index, index + 1], "　")
-                }));
+            matchCaptureGroupAll(text, matchAfter).forEach((match) => {
+                const { index } = match;
+                return report(
+                    node,
+                    new RuleError("文末に疑問符を使用し、後に別の文が続く場合は、直後に全角スペースを挿入します。", {
+                        index: index,
+                        fix: fixer.replaceTextRange([index, index + 1], "　")
+                    })
+                );
             });
         }
     };

packages/textlint-rule-ja-space-after-question/src/index.js

@@ -17,7 +17,7 @@ tester.run("疑問符(?)", rule, {
         "> どう操作したらよいのか？という",
         "**どう操作したらよいのか？という**",
         "[どう操作したらよいのか？という][]",
-        "[^どう操作したらよいのか？という]",
+        "[^どう操作したらよいのか？という]"
     ],
     invalid: [
         {