eslint-plugin-yml 0.8.0 → 0.10.1

package/README.md

@@ -26,6 +26,19 @@ This ESLint plugin provides linting rules for [YAML].
 
 You can check on the [Online DEMO](https://ota-meshi.github.io/eslint-plugin-yml/playground/).
 
+## :question: How is it different from other YAML plugins?
+
+### Plugins that do not use AST
+
+e.g. [eslint-plugin-yaml](https://www.npmjs.com/package/eslint-plugin-yaml)
+
+These plugins use the processor to parse and return the results independently, without providing the ESLint engine with AST and source code text.
+
+Plugins don't provide AST, so you can't use directive comments (e.g. `# eslint-disable`).  
+Plugins don't provide source code text, so you can't use it with plugins and rules that use text (e.g. [eslint-plugin-prettier](https://github.com/prettier/eslint-plugin-prettier), [eol-last](https://eslint.org/docs/rules/eol-last)).  
+
+**eslint-plugin-yml** works by providing AST and source code text to ESLint.
+
 <!--DOCS_IGNORE_START-->
 
 ## :book: Documentation
@@ -75,9 +88,33 @@ This plugin provides configs:
 - `plugin:yml/base` ... Configuration to enable correct YAML parsing.
 - `plugin:yml/recommended` ... Above, plus rules to prevent errors or unintended behavior.
 - `plugin:yml/standard` ... Above, plus rules to enforce the common stylistic conventions.
+- `plugin:yml/prettier` ... Turn off rules that may conflict with [Prettier](https://prettier.io/).
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-yml/rules/) to get the `rules` that this plugin provides.
 
+#### Parser Configuration
+
+If you have specified a parser, you need to configure a parser for `.yaml`.
+
+For example, if you are using the `"@babel/eslint-parser"`, configure it as follows:
+
+```js
+module.exports = {
+  // ...
+  extends: ["plugin:yml/standard"],
+  // ...
+  parser: "@babel/eslint-parser",
+  // Add an `overrides` section to add a parser configuration for YAML.
+  overrides: [
+    {
+      files: ["*.yaml", "*.yml"],
+      parser: "yaml-eslint-parser",
+    },
+  ],
+  // ...
+};
+```
+
 ### Running ESLint from the command line
 
 If you want to run `eslint` from the command line, make sure you include the `.yaml` extension using [the `--ext` option](https://eslint.org/docs/user-guide/configuring#specifying-file-extensions-to-lint) or a glob pattern, because ESLint targets only `.js` files by default.
@@ -157,8 +194,22 @@ The rules with the following star :star: are included in the config.
 <!--RULES_TABLE_END-->
 <!--RULES_SECTION_END-->
 
+## :rocket: To Do More Verification
+
+### Verify using JSON Schema
+
+You can verify using JSON Schema by checking and installing [eslint-plugin-json-schema-validator].
+
+### Verify the [Vue I18n] message resource files
+
+You can verify the message files by checking and installing [@intlify/eslint-plugin-vue-i18n].
+
 <!--DOCS_IGNORE_START-->
 
+<!-- ## :traffic_light: Semantic Versioning Policy
+
+**eslint-plugin-jsonc** follows [Semantic Versioning](http://semver.org/) and [ESLint's Semantic Versioning Policy](https://github.com/eslint/eslint#semantic-versioning-policy). -->
+
 ## :beers: Contributing
 
 Welcome contributing!
@@ -190,3 +241,6 @@ This plugin uses [yaml-eslint-parser](https://github.com/ota-meshi/yaml-eslint-p
 See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
 
 [YAML]: https://yaml.org/
+[eslint-plugin-json-schema-validator]: https://github.com/ota-meshi/eslint-plugin-json-schema-validator
+[@intlify/eslint-plugin-vue-i18n]: https://github.com/intlify/eslint-plugin-vue-i18n
+[Vue I18n]: https://github.com/intlify/vue-i18n-next

package/lib/configs/prettier.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    extends: string[];
+    rules: {
+        "yml/block-mapping-question-indicator-newline": string;
+        "yml/block-sequence-hyphen-indicator-newline": string;
+        "yml/flow-mapping-curly-newline": string;
+        "yml/flow-mapping-curly-spacing": string;
+        "yml/flow-sequence-bracket-newline": string;
+        "yml/flow-sequence-bracket-spacing": string;
+        "yml/indent": string;
+        "yml/key-spacing": string;
+        "yml/quotes": string;
+    };
+};
+export = _default;

package/lib/configs/prettier.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = __importDefault(require("path"));
+const base = require.resolve("./base");
+const baseExtend = path_1.default.extname(`${base}`) === ".ts" ? "plugin:yml/base" : base;
+module.exports = {
+    extends: [baseExtend],
+    rules: {
+        "yml/block-mapping-question-indicator-newline": "off",
+        "yml/block-sequence-hyphen-indicator-newline": "off",
+        "yml/flow-mapping-curly-newline": "off",
+        "yml/flow-mapping-curly-spacing": "off",
+        "yml/flow-sequence-bracket-newline": "off",
+        "yml/flow-sequence-bracket-spacing": "off",
+        "yml/indent": "off",
+        "yml/key-spacing": "off",
+        "yml/quotes": "off",
+    },
+};

package/lib/index.d.ts

@@ -49,6 +49,20 @@ declare const _default: {
                 "yml/vue-custom-block/no-parsing-error": string;
             };
         };
+        prettier: {
+            extends: string[];
+            rules: {
+                "yml/block-mapping-question-indicator-newline": string;
+                "yml/block-sequence-hyphen-indicator-newline": string;
+                "yml/flow-mapping-curly-newline": string;
+                "yml/flow-mapping-curly-spacing": string;
+                "yml/flow-sequence-bracket-newline": string;
+                "yml/flow-sequence-bracket-spacing": string;
+                "yml/indent": string;
+                "yml/key-spacing": string;
+                "yml/quotes": string;
+            };
+        };
     };
     rules: {
         [key: string]: RuleModule;

package/lib/index.js

@@ -6,10 +6,12 @@ const rules_1 = require("./utils/rules");
 const base_1 = __importDefault(require("./configs/base"));
 const recommended_1 = __importDefault(require("./configs/recommended"));
 const standard_1 = __importDefault(require("./configs/standard"));
+const prettier_1 = __importDefault(require("./configs/prettier"));
 const configs = {
     base: base_1.default,
     recommended: recommended_1.default,
     standard: standard_1.default,
+    prettier: prettier_1.default,
 };
 const rules = rules_1.rules.reduce((obj, r) => {
     obj[r.meta.docs.ruleName] = r;

package/lib/rules/block-mapping-question-indicator-newline.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("block-mapping-question-indicator-newline", {
+exports.default = (0, utils_1.createRule)("block-mapping-question-indicator-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks after `?` indicator",
             categories: ["standard"],
             extensionRule: false,
+            layout: true,
         },
         fixable: "whitespace",
         schema: [
@@ -38,7 +39,7 @@ exports.default = utils_1.createRule("block-mapping-question-indicator-newline",
                         continue;
                     }
                     const question = sourceCode.getFirstToken(pair);
-                    if (!question || !ast_utils_1.isQuestion(question)) {
+                    if (!question || !(0, ast_utils_1.isQuestion)(question)) {
                         continue;
                     }
                     const hasNewline = question.loc.end.line < key.loc.start.line;

package/lib/rules/block-mapping.js

@@ -25,12 +25,13 @@ function parseOptions(option) {
     }
     return opt;
 }
-exports.default = utils_1.createRule("block-mapping", {
+exports.default = (0, utils_1.createRule)("block-mapping", {
     meta: {
         docs: {
             description: "require or disallow block style mappings.",
             categories: ["standard"],
             extensionRule: false,
+            layout: false,
         },
         fixable: "code",
         schema: [
@@ -129,11 +130,11 @@ exports.default = utils_1.createRule("block-mapping", {
                     if (optionType === "never") {
                         return;
                     }
-                    if (yaml_1.isKeyNode(node)) {
+                    if ((0, yaml_1.isKeyNode)(node)) {
                         return;
                     }
                     const canFix = canFixToBlock(mappingInfo, node) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "required",
@@ -146,7 +147,7 @@ exports.default = utils_1.createRule("block-mapping", {
                         return;
                     }
                     const canFix = canFixToFlow(mappingInfo, node) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "disallow",
@@ -181,8 +182,8 @@ function canFixToFlow(mappingInfo, node) {
         return false;
     }
     for (const pair of node.pairs) {
-        const value = yaml_1.unwrapMeta(pair.value);
-        const key = yaml_1.unwrapMeta(pair.key);
+        const value = (0, yaml_1.unwrapMeta)(pair.value);
+        const key = (0, yaml_1.unwrapMeta)(pair.key);
         if (value && value.type === "YAMLScalar" && value.style === "plain") {
             if (value.loc.start.line < value.loc.end.line) {
                 return false;
@@ -213,7 +214,7 @@ function buildFixFlowToBlock(node, context) {
         if ((open === null || open === void 0 ? void 0 : open.value) !== "{" || (close === null || close === void 0 ? void 0 : close.value) !== "}") {
             return;
         }
-        const expectIndent = yaml_1.calcExpectIndentForPairs(node, context);
+        const expectIndent = (0, yaml_1.calcExpectIndentForPairs)(node, context);
         if (expectIndent == null) {
             return;
         }
@@ -233,7 +234,7 @@ function buildFixFlowToBlock(node, context) {
         for (const pair of node.pairs) {
             const prevToken = sourceCode.getTokenBefore(pair, {
                 includeComments: true,
-                filter: (token) => !ast_utils_1.isComma(token),
+                filter: (token) => !(0, ast_utils_1.isComma)(token),
             });
             yield* removeComma(prev, prevToken);
             yield fixer.replaceTextRange([prevToken.range[1], pair.range[0]], `\n${expectIndent}`);
@@ -244,7 +245,7 @@ function buildFixFlowToBlock(node, context) {
                 }).range[0]) {
                 yield fixer.insertTextAfter(colonToken, " ");
             }
-            yield* yaml_1.processIndentFix(fixer, expectIndent, pair.value, context);
+            yield* (0, yaml_1.processIndentFix)(fixer, expectIndent, pair.value, context);
             prev = pair;
         }
         yield* removeComma(prev, close);
@@ -253,7 +254,7 @@ function buildFixFlowToBlock(node, context) {
             for (const token of sourceCode.getTokensBetween(a, b, {
                 includeComments: true,
             })) {
-                if (ast_utils_1.isComma(token)) {
+                if ((0, ast_utils_1.isComma)(token)) {
                     yield fixer.remove(token);
                 }
             }

package/lib/rules/block-sequence-hyphen-indicator-newline.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("block-sequence-hyphen-indicator-newline", {
+exports.default = (0, utils_1.createRule)("block-sequence-hyphen-indicator-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks after `-` indicator",
             categories: ["standard"],
             extensionRule: false,
+            layout: true,
         },
         fixable: "whitespace",
         schema: [
@@ -36,7 +37,7 @@ exports.default = utils_1.createRule("block-sequence-hyphen-indicator-newline",
         const nestedHyphenStyle = ((_a = context.options[1]) === null || _a === void 0 ? void 0 : _a.nestedHyphen) || "always";
         function getStyleOption(hyphen) {
             const next = sourceCode.getTokenAfter(hyphen);
-            if (next && ast_utils_1.isHyphen(next)) {
+            if (next && (0, ast_utils_1.isHyphen)(next)) {
                 return nestedHyphenStyle;
             }
             return style;

package/lib/rules/block-sequence.js

@@ -25,12 +25,13 @@ function parseOptions(option) {
     }
     return opt;
 }
-exports.default = utils_1.createRule("block-sequence", {
+exports.default = (0, utils_1.createRule)("block-sequence", {
     meta: {
         docs: {
             description: "require or disallow block style sequences.",
             categories: ["standard"],
             extensionRule: false,
+            layout: false,
         },
         fixable: "code",
         schema: [
@@ -129,10 +130,10 @@ exports.default = utils_1.createRule("block-sequence", {
                     if (optionType === "never") {
                         return;
                     }
-                    if (yaml_1.isKeyNode(node)) {
+                    if ((0, yaml_1.isKeyNode)(node)) {
                         return;
                     }
-                    const canFix = canFixToBlock(sequenceInfo, node, context.getSourceCode()) && !yaml_1.hasTabIndent(context);
+                    const canFix = canFixToBlock(sequenceInfo, node, context.getSourceCode()) && !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "required",
@@ -145,7 +146,7 @@ exports.default = utils_1.createRule("block-sequence", {
                         return;
                     }
                     const canFix = canFixToFlow(sequenceInfo, node, context) &&
-                        !yaml_1.hasTabIndent(context);
+                        !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
                         messageId: "disallow",
@@ -196,17 +197,17 @@ function canFixToFlow(sequenceInfo, node, context) {
         return false;
     }
     if (node.parent.type === "YAMLWithMeta") {
-        const metaIndent = yaml_1.getActualIndent(node.parent, context);
+        const metaIndent = (0, yaml_1.getActualIndent)(node.parent, context);
         if (metaIndent != null) {
             for (let line = node.loc.start.line; line <= node.loc.end.line; line++) {
-                if (yaml_1.compareIndent(metaIndent, yaml_1.getActualIndentFromLine(line, context)) > 0) {
+                if ((0, yaml_1.compareIndent)(metaIndent, (0, yaml_1.getActualIndentFromLine)(line, context)) > 0) {
                     return false;
                 }
             }
         }
     }
     for (const entry of node.entries) {
-        const value = yaml_1.unwrapMeta(entry);
+        const value = (0, yaml_1.unwrapMeta)(entry);
         if (value && value.type === "YAMLScalar" && value.style === "plain") {
             if (value.strValue.includes(",")) {
                 return false;
@@ -223,7 +224,7 @@ function buildFixFlowToBlock(node, context) {
         if ((open === null || open === void 0 ? void 0 : open.value) !== "[" || (close === null || close === void 0 ? void 0 : close.value) !== "]") {
             return;
         }
-        const expectIndent = yaml_1.calcExpectIndentForEntries(node, context);
+        const expectIndent = (0, yaml_1.calcExpectIndentForEntries)(node, context);
         if (expectIndent == null) {
             return;
         }
@@ -243,7 +244,7 @@ function buildFixFlowToBlock(node, context) {
         for (const entry of node.entries) {
             const prevToken = sourceCode.getTokenBefore(entry, {
                 includeComments: true,
-                filter: (token) => !ast_utils_1.isComma(token),
+                filter: (token) => !(0, ast_utils_1.isComma)(token),
             });
             yield* removeComma(prev, prevToken);
             yield fixer.replaceTextRange([prevToken.range[1], entry.range[0]], `\n${expectIndent}- `);
@@ -256,33 +257,33 @@ function buildFixFlowToBlock(node, context) {
             for (const token of sourceCode.getTokensBetween(a, b, {
                 includeComments: true,
             })) {
-                if (ast_utils_1.isComma(token)) {
+                if ((0, ast_utils_1.isComma)(token)) {
                     yield fixer.remove(token);
                 }
             }
         }
         function* processEntryIndent(baseIndent, entry) {
             if (entry.type === "YAMLWithMeta" && entry.value) {
-                yield* yaml_1.processIndentFix(fixer, baseIndent, entry.value, context);
+                yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, entry.value, context);
             }
             else if (entry.type === "YAMLMapping") {
                 for (const p of entry.pairs) {
                     if (p.range[0] === entry.range[0]) {
                         if (p.value) {
-                            yield* yaml_1.processIndentFix(fixer, baseIndent, p.value, context);
+                            yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, p.value, context);
                         }
                     }
                     else {
-                        yield* yaml_1.processIndentFix(fixer, baseIndent, p, context);
+                        yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, p, context);
                     }
                 }
                 if (entry.style === "flow") {
                     const close = sourceCode.getLastToken(entry);
                     if (close.value === "}") {
-                        const actualIndent = yaml_1.getActualIndent(close, context);
+                        const actualIndent = (0, yaml_1.getActualIndent)(close, context);
                         if (actualIndent != null &&
-                            yaml_1.compareIndent(actualIndent, baseIndent) < 0) {
-                            yield yaml_1.fixIndent(fixer, sourceCode, baseIndent, close);
+                            (0, yaml_1.compareIndent)(actualIndent, baseIndent) < 0) {
+                            yield (0, yaml_1.fixIndent)(fixer, sourceCode, baseIndent, close);
                         }
                     }
                 }
@@ -292,7 +293,7 @@ function buildFixFlowToBlock(node, context) {
                     if (!e) {
                         continue;
                     }
-                    yield* yaml_1.processIndentFix(fixer, baseIndent, e, context);
+                    yield* (0, yaml_1.processIndentFix)(fixer, baseIndent, e, context);
                 }
             }
         }

package/lib/rules/flow-mapping-curly-newline.js

@@ -56,12 +56,13 @@ function areLineBreaksRequired(node, options, first, last) {
             objectProperties.length > 0 &&
             first.loc.start.line !== last.loc.end.line));
 }
-exports.default = utils_1.createRule("flow-mapping-curly-newline", {
+exports.default = (0, utils_1.createRule)("flow-mapping-curly-newline", {
     meta: {
         docs: {
             description: "enforce consistent line breaks inside braces",
             categories: ["standard"],
             extensionRule: "object-curly-newline",
+            layout: true,
         },
         fixable: "whitespace",
         schema: [OPTION_VALUE],
@@ -80,7 +81,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
         const sourceCode = context.getSourceCode();
         const options = normalizeOptionValue(context.options[0]);
         function check(node) {
-            if (yaml_1.isKeyNode(node)) {
+            if ((0, yaml_1.isKeyNode)(node)) {
                 return;
             }
             const openBrace = sourceCode.getFirstToken(node, (token) => token.value === "{");
@@ -92,37 +93,37 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                 includeComments: true,
             });
             const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
-            const hasCommentsFirstToken = ast_utils_1.isCommentToken(first);
-            const hasCommentsLastToken = ast_utils_1.isCommentToken(last);
-            const hasQuestionsLastToken = ast_utils_1.isQuestion(last);
+            const hasCommentsFirstToken = (0, ast_utils_1.isCommentToken)(first);
+            const hasCommentsLastToken = (0, ast_utils_1.isCommentToken)(last);
+            const hasQuestionsLastToken = (0, ast_utils_1.isQuestion)(last);
             first = sourceCode.getTokenAfter(openBrace);
             last = sourceCode.getTokenBefore(closeBrace);
             if (needsLineBreaks) {
-                if (ast_utils_1.isTokenOnSameLine(openBrace, first)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(openBrace, first)) {
                     context.report({
                         messageId: "expectedLinebreakAfterOpeningBrace",
                         node,
                         loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken ||
-                                yaml_1.hasTabIndent(context)) {
+                                (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
-                            const indent = yaml_1.incIndent(yaml_1.getActualIndentFromLine(openBrace.loc.start.line, context), context);
+                            const indent = (0, yaml_1.incIndent)((0, yaml_1.getActualIndentFromLine)(openBrace.loc.start.line, context), context);
                             return fixer.insertTextAfter(openBrace, `\n${indent}`);
                         },
                     });
                 }
-                if (ast_utils_1.isTokenOnSameLine(last, closeBrace)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(last, closeBrace)) {
                     context.report({
                         messageId: "expectedLinebreakBeforeClosingBrace",
                         node,
                         loc: closeBrace.loc,
                         fix(fixer) {
-                            if (hasCommentsLastToken || yaml_1.hasTabIndent(context)) {
+                            if (hasCommentsLastToken || (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
-                            const indent = yaml_1.getActualIndentFromLine(closeBrace.loc.start.line, context);
+                            const indent = (0, yaml_1.getActualIndentFromLine)(closeBrace.loc.start.line, context);
                             return fixer.insertTextBefore(closeBrace, `\n${indent}`);
                         },
                     });
@@ -130,8 +131,8 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
             }
             else {
                 const consistent = options.consistent;
-                const hasLineBreakBetweenOpenBraceAndFirst = !ast_utils_1.isTokenOnSameLine(openBrace, first);
-                const hasLineBreakBetweenCloseBraceAndLast = !ast_utils_1.isTokenOnSameLine(last, closeBrace);
+                const hasLineBreakBetweenOpenBraceAndFirst = !(0, ast_utils_1.isTokenOnSameLine)(openBrace, first);
+                const hasLineBreakBetweenCloseBraceAndLast = !(0, ast_utils_1.isTokenOnSameLine)(last, closeBrace);
                 if ((!consistent && hasLineBreakBetweenOpenBraceAndFirst) ||
                     (consistent &&
                         hasLineBreakBetweenOpenBraceAndFirst &&
@@ -142,7 +143,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                         loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken ||
-                                yaml_1.hasTabIndent(context)) {
+                                (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
                             return fixer.removeRange([
@@ -164,7 +165,7 @@ exports.default = utils_1.createRule("flow-mapping-curly-newline", {
                         node,
                         loc: closeBrace.loc,
                         fix(fixer) {
-                            if (hasCommentsLastToken || yaml_1.hasTabIndent(context)) {
+                            if (hasCommentsLastToken || (0, yaml_1.hasTabIndent)(context)) {
                                 return null;
                             }
                             return fixer.removeRange([

package/lib/rules/flow-mapping-curly-spacing.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = utils_1.getCoreRule("object-curly-spacing");
-exports.default = utils_1.createRule("flow-mapping-curly-spacing", {
+const coreRule = (0, utils_1.getCoreRule)("object-curly-spacing");
+exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
     meta: {
         docs: {
             description: "enforce consistent spacing inside braces",
             categories: ["standard"],
             extensionRule: "object-curly-spacing",
+            layout: true,
         },
         fixable: coreRule.meta.fixable,
+        hasSuggestions: coreRule.meta.hasSuggestions,
         schema: coreRule.meta.schema,
         messages: coreRule.meta.messages,
         type: coreRule.meta.type,
@@ -18,13 +20,13 @@ exports.default = utils_1.createRule("flow-mapping-curly-spacing", {
         if (!context.parserServices.isYAML) {
             return {};
         }
-        return utils_1.defineWrapperListener(coreRule, context, {
+        return (0, utils_1.defineWrapperListener)(coreRule, context, {
             options: context.options,
             createListenerProxy(listener) {
                 return {
                     YAMLMapping(node) {
                         if (node.style === "flow") {
-                            listener.ObjectExpression(utils_1.getProxyNode(node, {
+                            listener.ObjectExpression((0, utils_1.getProxyNode)(node, {
                                 type: "ObjectExpression",
                                 get properties() {
                                     return node.pairs;

package/lib/rules/flow-sequence-bracket-newline.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const yaml_1 = require("../utils/yaml");
 const ast_utils_1 = require("../utils/ast-utils");
-exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
+exports.default = (0, utils_1.createRule)("flow-sequence-bracket-newline", {
     meta: {
         docs: {
             description: "enforce linebreaks after opening and before closing flow sequence brackets",
             categories: ["standard"],
             extensionRule: "array-bracket-newline",
+            layout: true,
         },
         fixable: "whitespace",
         schema: [
@@ -80,13 +81,13 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "unexpectedOpeningLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
                     const nextToken = sourceCode.getTokenAfter(token, {
                         includeComments: true,
                     });
-                    if (ast_utils_1.isCommentToken(nextToken)) {
+                    if ((0, ast_utils_1.isCommentToken)(nextToken)) {
                         return null;
                     }
                     return fixer.removeRange([
@@ -102,13 +103,13 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "unexpectedClosingLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
                     const previousToken = sourceCode.getTokenBefore(token, {
                         includeComments: true,
                     });
-                    if (ast_utils_1.isCommentToken(previousToken)) {
+                    if ((0, ast_utils_1.isCommentToken)(previousToken)) {
                         return null;
                     }
                     return fixer.removeRange([
@@ -124,10 +125,10 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "missingOpeningLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
-                    const indent = yaml_1.incIndent(yaml_1.getActualIndentFromLine(token.loc.start.line, context), context);
+                    const indent = (0, yaml_1.incIndent)((0, yaml_1.getActualIndentFromLine)(token.loc.start.line, context), context);
                     return fixer.insertTextAfter(token, `\n${indent}`);
                 },
             });
@@ -138,16 +139,16 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 loc: token.loc,
                 messageId: "missingClosingLinebreak",
                 fix(fixer) {
-                    if (yaml_1.hasTabIndent(context)) {
+                    if ((0, yaml_1.hasTabIndent)(context)) {
                         return null;
                     }
-                    const indent = yaml_1.getActualIndentFromLine(token.loc.start.line, context);
+                    const indent = (0, yaml_1.getActualIndentFromLine)(token.loc.start.line, context);
                     return fixer.insertTextBefore(token, `\n${indent}`);
                 },
             });
         }
         function check(node) {
-            if (yaml_1.isKeyNode(node)) {
+            if ((0, yaml_1.isKeyNode)(node)) {
                 return;
             }
             const elements = node.entries;
@@ -175,18 +176,18 @@ exports.default = utils_1.createRule("flow-sequence-bracket-newline", {
                 (options.consistent &&
                     openBracket.loc.end.line !== first.loc.start.line);
             if (needsLinebreaks) {
-                if (ast_utils_1.isTokenOnSameLine(openBracket, first)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(openBracket, first)) {
                     reportRequiredBeginningLinebreak(node, openBracket);
                 }
-                if (ast_utils_1.isTokenOnSameLine(last, closeBracket)) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(last, closeBracket)) {
                     reportRequiredEndingLinebreak(node, closeBracket);
                 }
             }
             else {
-                if (!ast_utils_1.isTokenOnSameLine(openBracket, first)) {
+                if (!(0, ast_utils_1.isTokenOnSameLine)(openBracket, first)) {
                     reportNoBeginningLinebreak(node, openBracket);
                 }
-                if (!ast_utils_1.isTokenOnSameLine(last, closeBracket)) {
+                if (!(0, ast_utils_1.isTokenOnSameLine)(last, closeBracket)) {
                     reportNoEndingLinebreak(node, closeBracket);
                 }
             }