eslint-plugin-toml 0.7.0 → 0.8.0

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name: "eslint-plugin-toml";
-export declare const version: "0.7.0";
+export declare const version: "0.8.0";

package/lib/meta.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = "eslint-plugin-toml";
-exports.version = "0.7.0";
+exports.version = "0.8.0";

package/lib/rules/array-bracket-newline.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("array-bracket-newline");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("array-bracket-newline", {
     meta: {
         docs: {
@@ -9,22 +10,164 @@ exports.default = (0, utils_1.createRule)("array-bracket-newline", {
             categories: ["standard"],
             extensionRule: "array-bracket-newline",
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
-    },
-    create(context) {
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
-                return {
-                    TOMLArray(node) {
-                        listener.ArrayExpression((0, utils_1.convertESNode)(node));
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: "string",
+                        enum: ["always", "never", "consistent"],
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            multiline: {
+                                type: "boolean",
+                            },
+                            minItems: {
+                                type: ["integer", "null"],
+                                minimum: 0,
+                            },
+                        },
+                        additionalProperties: false,
                     },
-                };
+                ],
             },
-        });
+        ],
+        messages: {
+            unexpectedOpeningLinebreak: "There should be no linebreak after '['.",
+            unexpectedClosingLinebreak: "There should be no linebreak before ']'.",
+            missingOpeningLinebreak: "A linebreak is required after '['.",
+            missingClosingLinebreak: "A linebreak is required before ']'.",
+        },
+    },
+    create(context) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isTOML) {
+            return {};
+        }
+        function normalizeOptionValue(option) {
+            let consistent = false;
+            let multiline = false;
+            let minItems = 0;
+            if (option) {
+                if (option === "consistent") {
+                    consistent = true;
+                    minItems = Number.POSITIVE_INFINITY;
+                }
+                else if (option === "always" ||
+                    (typeof option !== "string" && option.minItems === 0)) {
+                    minItems = 0;
+                }
+                else if (option === "never") {
+                    minItems = Number.POSITIVE_INFINITY;
+                }
+                else {
+                    multiline = Boolean(option.multiline);
+                    minItems = option.minItems || Number.POSITIVE_INFINITY;
+                }
+            }
+            else {
+                consistent = false;
+                multiline = true;
+                minItems = Number.POSITIVE_INFINITY;
+            }
+            return { consistent, multiline, minItems };
+        }
+        function normalizeOptions(options) {
+            const value = normalizeOptionValue(options);
+            return { TOMLArray: value };
+        }
+        function reportNoBeginningLinebreak(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "unexpectedOpeningLinebreak",
+                fix(fixer) {
+                    const nextToken = sourceCode.getTokenAfter(token, {
+                        includeComments: true,
+                    });
+                    if (!nextToken || (0, ast_utils_1.isCommentToken)(nextToken))
+                        return null;
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingLinebreak(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "unexpectedClosingLinebreak",
+                fix(fixer) {
+                    const previousToken = sourceCode.getTokenBefore(token, {
+                        includeComments: true,
+                    });
+                    if (!previousToken || (0, ast_utils_1.isCommentToken)(previousToken))
+                        return null;
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningLinebreak(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingOpeningLinebreak",
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, "\n");
+                },
+            });
+        }
+        function reportRequiredEndingLinebreak(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingClosingLinebreak",
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, "\n");
+                },
+            });
+        }
+        function check(node) {
+            const elements = node.elements;
+            const normalizedOptions = normalizeOptions(context.options[0]);
+            const options = normalizedOptions[node.type];
+            const openBracket = sourceCode.getFirstToken(node);
+            const closeBracket = sourceCode.getLastToken(node);
+            const firstIncComment = sourceCode.getTokenAfter(openBracket, {
+                includeComments: true,
+            });
+            const lastIncComment = sourceCode.getTokenBefore(closeBracket, {
+                includeComments: true,
+            });
+            const first = sourceCode.getTokenAfter(openBracket);
+            const last = sourceCode.getTokenBefore(closeBracket);
+            const needsLinebreaks = elements.length >= options.minItems ||
+                (options.multiline &&
+                    elements.length > 0 &&
+                    firstIncComment.loc.start.line !== lastIncComment.loc.end.line) ||
+                (elements.length === 0 &&
+                    firstIncComment.type === "Block" &&
+                    firstIncComment.loc.start.line !== lastIncComment.loc.end.line &&
+                    firstIncComment === lastIncComment) ||
+                (options.consistent &&
+                    openBracket.loc.end.line !== first.loc.start.line);
+            if (needsLinebreaks) {
+                if ((0, ast_utils_1.isTokenOnSameLine)(openBracket, first))
+                    reportRequiredBeginningLinebreak(node, openBracket);
+                if ((0, ast_utils_1.isTokenOnSameLine)(last, closeBracket))
+                    reportRequiredEndingLinebreak(node, closeBracket);
+            }
+            else {
+                if (!(0, ast_utils_1.isTokenOnSameLine)(openBracket, first))
+                    reportNoBeginningLinebreak(node, openBracket);
+                if (!(0, ast_utils_1.isTokenOnSameLine)(last, closeBracket))
+                    reportNoEndingLinebreak(node, closeBracket);
+            }
+        }
+        return {
+            TOMLArray: check,
+        };
     },
 });

package/lib/rules/array-bracket-spacing.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("array-bracket-spacing");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("array-bracket-spacing", {
     meta: {
         docs: {
@@ -9,22 +10,169 @@ exports.default = (0, utils_1.createRule)("array-bracket-spacing", {
             categories: ["standard"],
             extensionRule: "array-bracket-spacing",
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    singleValue: {
+                        type: "boolean",
+                    },
+                    objectsInArrays: {
+                        type: "boolean",
+                    },
+                    arraysInArrays: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
+            missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
+            missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
+        },
     },
     create(context) {
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: [context.options[0] || "always", ...context.options.slice(1)],
-            createListenerProxy(listener) {
-                return {
-                    TOMLArray(node) {
-                        listener.ArrayExpression((0, utils_1.convertESNode)(node));
-                    },
-                };
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isTOML) {
+            return {};
+        }
+        const spaced = (context.options[0] || "always") === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            singleElementException: isOptionSet("singleValue"),
+            objectsInArraysException: isOptionSet("objectsInArrays"),
+            arraysInArraysException: isOptionSet("arraysInArrays"),
+            isOpeningBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.elements.length === 1) {
+                    return !options.spaced;
+                }
+                const firstElement = node.elements[0];
+                return firstElement &&
+                    ((options.objectsInArraysException && isObjectType(firstElement)) ||
+                        (options.arraysInArraysException && isArrayType(firstElement)))
+                    ? !options.spaced
+                    : options.spaced;
+            },
+            isClosingBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.elements.length === 1) {
+                    return !options.spaced;
+                }
+                const lastElement = node.elements[node.elements.length - 1];
+                return lastElement &&
+                    ((options.objectsInArraysException && isObjectType(lastElement)) ||
+                        (options.arraysInArraysException && isArrayType(lastElement)))
+                    ? !options.spaced
+                    : options.spaced;
             },
-        });
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token);
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token);
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function isObjectType(node) {
+            return node && node.type === "TOMLInlineTable";
+        }
+        function isArrayType(node) {
+            return node && node.type === "TOMLArray";
+        }
+        function validateArraySpacing(node) {
+            if (options.spaced && node.elements.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = sourceCode.getLastToken(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                if (options.isOpeningBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(first, second))
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(first, second))
+                        reportNoBeginningSpace(node, first);
+                }
+            }
+            if (first !== penultimate && (0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                if (options.isClosingBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        return {
+            TOMLArray: validateArraySpacing,
+        };
     },
 });

package/lib/rules/array-element-newline.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("array-element-newline");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("array-element-newline", {
     meta: {
         docs: {
@@ -9,22 +10,193 @@ exports.default = (0, utils_1.createRule)("array-element-newline", {
             categories: ["standard"],
             extensionRule: "array-element-newline",
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: {
+            definitions: {
+                basicConfig: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            enum: ["always", "never", "consistent"],
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                multiline: {
+                                    type: "boolean",
+                                },
+                                minItems: {
+                                    type: ["integer", "null"],
+                                    minimum: 0,
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    ],
+                },
+            },
+            type: "array",
+            items: [
+                {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/basicConfig",
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                ArrayExpression: {
+                                    $ref: "#/definitions/basicConfig",
+                                },
+                                ArrayPattern: {
+                                    $ref: "#/definitions/basicConfig",
+                                },
+                                TOMLArray: {
+                                    $ref: "#/definitions/basicConfig",
+                                },
+                            },
+                            additionalProperties: false,
+                            minProperties: 1,
+                        },
+                    ],
+                },
+            ],
+        },
+        messages: {
+            unexpectedLineBreak: "There should be no linebreak here.",
+            missingLineBreak: "There should be a linebreak after this element.",
+        },
     },
     create(context) {
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isTOML) {
+            return {};
+        }
+        function normalizeOptionValue(providedOption) {
+            let consistent = false;
+            let multiline = false;
+            let minItems;
+            const option = providedOption || "always";
+            if (!option ||
+                option === "always" ||
+                (typeof option === "object" && option.minItems === 0)) {
+                minItems = 0;
+            }
+            else if (option === "never") {
+                minItems = Number.POSITIVE_INFINITY;
+            }
+            else if (option === "consistent") {
+                consistent = true;
+                minItems = Number.POSITIVE_INFINITY;
+            }
+            else {
+                multiline = Boolean(option.multiline);
+                minItems = option.minItems || Number.POSITIVE_INFINITY;
+            }
+            return { consistent, multiline, minItems };
+        }
+        function normalizeOptions(options) {
+            if (options && (options.ArrayExpression || options.TOMLArray)) {
+                let expressionOptions;
+                if (options.ArrayExpression)
+                    expressionOptions = normalizeOptionValue(options.ArrayExpression);
+                if (options.TOMLArray)
+                    expressionOptions = normalizeOptionValue(options.TOMLArray);
                 return {
-                    TOMLArray(node) {
-                        listener.ArrayExpression((0, utils_1.convertESNode)(node));
-                    },
+                    TOMLArray: expressionOptions,
                 };
-            },
-        });
+            }
+            const value = normalizeOptionValue(options);
+            return { TOMLArray: value };
+        }
+        function reportNoLineBreak(token) {
+            const tokenBefore = sourceCode.getTokenBefore(token, {
+                includeComments: true,
+            });
+            context.report({
+                loc: {
+                    start: tokenBefore.loc.end,
+                    end: token.loc.start,
+                },
+                messageId: "unexpectedLineBreak",
+                fix(fixer) {
+                    if ((0, ast_utils_1.isCommentToken)(tokenBefore))
+                        return null;
+                    if (!(0, ast_utils_1.isTokenOnSameLine)(tokenBefore, token))
+                        return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ");
+                    const twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, {
+                        includeComments: true,
+                    });
+                    if ((0, ast_utils_1.isCommentToken)(twoTokensBefore))
+                        return null;
+                    return fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], "");
+                },
+            });
+        }
+        function reportRequiredLineBreak(token) {
+            const tokenBefore = sourceCode.getTokenBefore(token, {
+                includeComments: true,
+            });
+            context.report({
+                loc: {
+                    start: tokenBefore.loc.end,
+                    end: token.loc.start,
+                },
+                messageId: "missingLineBreak",
+                fix(fixer) {
+                    return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n");
+                },
+            });
+        }
+        function check(node) {
+            const elements = node.elements;
+            const normalizedOptions = normalizeOptions(context.options[0]);
+            const options = normalizedOptions[node.type];
+            if (!options)
+                return;
+            let elementBreak = false;
+            if (options.multiline) {
+                elementBreak = elements
+                    .filter((element) => element !== null)
+                    .some((element) => element.loc.start.line !== element.loc.end.line);
+            }
+            let linebreaksCount = 0;
+            for (let i = 0; i < node.elements.length; i++) {
+                const element = node.elements[i];
+                const previousElement = elements[i - 1];
+                if (i === 0 || element === null || previousElement === null)
+                    continue;
+                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, ast_utils_1.isCommaToken);
+                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
+                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
+                if (!(0, ast_utils_1.isTokenOnSameLine)(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
+                    linebreaksCount++;
+            }
+            const needsLinebreaks = elements.length >= options.minItems ||
+                (options.multiline && elementBreak) ||
+                (options.consistent &&
+                    linebreaksCount > 0 &&
+                    linebreaksCount < node.elements.length);
+            elements.forEach((element, i) => {
+                const previousElement = elements[i - 1];
+                if (i === 0 || element === null || previousElement === null)
+                    return;
+                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, ast_utils_1.isCommaToken);
+                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
+                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
+                if (needsLinebreaks) {
+                    if ((0, ast_utils_1.isTokenOnSameLine)(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
+                        reportRequiredLineBreak(firstTokenOfCurrentElement);
+                }
+                else {
+                    if (!(0, ast_utils_1.isTokenOnSameLine)(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
+                        reportNoLineBreak(firstTokenOfCurrentElement);
+                }
+            });
+        }
+        return {
+            TOMLArray: check,
+        };
     },
 });

package/lib/rules/comma-style.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const compat_1 = require("../utils/compat");
-const coreRule = (0, utils_1.getCoreRule)("comma-style");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("comma-style", {
     meta: {
         docs: {
@@ -10,26 +10,155 @@ exports.default = (0, utils_1.createRule)("comma-style", {
             categories: ["standard"],
             extensionRule: "comma-style",
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "code",
+        schema: [
+            {
+                type: "string",
+                enum: ["first", "last"],
+            },
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "boolean",
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpectedLineBeforeAndAfterComma: "Bad line breaking before and after ','.",
+            expectedCommaFirst: "',' should be placed first.",
+            expectedCommaLast: "',' should be placed last.",
+        },
     },
     create(context) {
+        var _a;
+        var _b;
         const sourceCode = (0, compat_1.getSourceCode)(context);
         if (!sourceCode.parserServices.isTOML) {
             return {};
         }
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: [context.options[0]],
-            createListenerProxy(listener) {
-                return {
-                    TOMLArray(node) {
-                        listener.ArrayExpression((0, utils_1.convertESNode)(node));
-                    },
-                };
-            },
-        });
+        const style = context.options[0] || "last";
+        const exceptions = {};
+        if (context.options.length === 2 &&
+            Object.prototype.hasOwnProperty.call(context.options[1], "exceptions")) {
+            (_a = (_b = context.options)[1]) !== null && _a !== void 0 ? _a : (_b[1] = { exceptions: {} });
+            const rawExceptions = context.options[1].exceptions;
+            const keys = Object.keys(rawExceptions);
+            for (let i = 0; i < keys.length; i++)
+                exceptions[keys[i]] = rawExceptions[keys[i]];
+        }
+        function getReplacedText(styleType, text) {
+            switch (styleType) {
+                case "between":
+                    return `,${text.replace(ast_utils_1.LINEBREAK_MATCHER, "")}`;
+                case "first":
+                    return `${text},`;
+                case "last":
+                    return `,${text}`;
+                default:
+                    return "";
+            }
+        }
+        function getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken) {
+            const text = sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) +
+                sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]);
+            const range = [
+                previousItemToken.range[1],
+                currentItemToken.range[0],
+            ];
+            return function (fixer) {
+                return fixer.replaceTextRange(range, getReplacedText(styleType, text));
+            };
+        }
+        function validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem) {
+            if ((0, ast_utils_1.isTokenOnSameLine)(commaToken, currentItemToken) &&
+                (0, ast_utils_1.isTokenOnSameLine)(previousItemToken, commaToken)) {
+            }
+            else if (!(0, ast_utils_1.isTokenOnSameLine)(commaToken, currentItemToken) &&
+                !(0, ast_utils_1.isTokenOnSameLine)(previousItemToken, commaToken)) {
+                const comment = sourceCode.getCommentsAfter(commaToken)[0];
+                const styleType = comment &&
+                    comment.type === "Block" &&
+                    (0, ast_utils_1.isTokenOnSameLine)(commaToken, comment)
+                    ? style
+                    : "between";
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "unexpectedLineBeforeAndAfterComma",
+                    fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken),
+                });
+            }
+            else if (style === "first" &&
+                !(0, ast_utils_1.isTokenOnSameLine)(commaToken, currentItemToken)) {
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "expectedCommaFirst",
+                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken),
+                });
+            }
+            else if (style === "last" &&
+                (0, ast_utils_1.isTokenOnSameLine)(commaToken, currentItemToken)) {
+                context.report({
+                    node: reportItem,
+                    loc: commaToken.loc,
+                    messageId: "expectedCommaLast",
+                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken),
+                });
+            }
+        }
+        function validateComma(node, property) {
+            const items = node[property];
+            const arrayLiteral = node.type === "TOMLArray";
+            if (items.length > 1 || arrayLiteral) {
+                let previousItemToken = sourceCode.getFirstToken(node);
+                items.forEach((item) => {
+                    const commaToken = item
+                        ? sourceCode.getTokenBefore(item)
+                        : previousItemToken;
+                    const currentItemToken = item
+                        ? sourceCode.getFirstToken(item)
+                        : sourceCode.getTokenAfter(commaToken);
+                    const reportItem = item || currentItemToken;
+                    if ((0, ast_utils_1.isCommaToken)(commaToken))
+                        validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem);
+                    if (item) {
+                        const tokenAfterItem = sourceCode.getTokenAfter(item, ast_utils_1.isNotClosingParenToken);
+                        previousItemToken = tokenAfterItem
+                            ? sourceCode.getTokenBefore(tokenAfterItem)
+                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                    }
+                    else {
+                        previousItemToken = currentItemToken;
+                    }
+                });
+                if (arrayLiteral) {
+                    const lastToken = sourceCode.getLastToken(node);
+                    const nextToLastToken = sourceCode.getTokenBefore(lastToken);
+                    if ((0, ast_utils_1.isCommaToken)(nextToLastToken)) {
+                        validateCommaItemSpacing(sourceCode.getTokenBefore(nextToLastToken), nextToLastToken, lastToken, lastToken);
+                    }
+                }
+            }
+        }
+        const nodes = {};
+        if (!exceptions.ObjectExpression && !exceptions.TOMLInlineTable) {
+            nodes.TOMLInlineTable = function (node) {
+                validateComma(node, "body");
+            };
+        }
+        if (!exceptions.ArrayExpression && !exceptions.TOMLArray) {
+            nodes.TOMLArray = function (node) {
+                validateComma(node, "elements");
+            };
+        }
+        return nodes;
     },
 });

package/lib/rules/inline-table-curly-spacing.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("object-curly-spacing");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("inline-table-curly-spacing", {
     meta: {
         docs: {
@@ -9,23 +10,168 @@ exports.default = (0, utils_1.createRule)("inline-table-curly-spacing", {
             categories: ["standard"],
             extensionRule: "object-curly-spacing",
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    arraysInObjects: {
+                        type: "boolean",
+                    },
+                    objectsInObjects: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireSpaceBefore: "A space is required before '{{token}}'.",
+            requireSpaceAfter: "A space is required after '{{token}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{token}}'.",
+            unexpectedSpaceAfter: "There should be no space after '{{token}}'.",
+        },
     },
     create(context) {
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: [context.options[0] || "always", ...context.options.slice(1)],
-            createListenerProxy(listener) {
-                return {
-                    TOMLInlineTable(node) {
-                        listener.ObjectExpression((0, utils_1.convertESNode)(node));
-                    },
-                };
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isTOML) {
+            return {};
+        }
+        const spaced = (context.options[0] || "always") === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            arraysInObjectsException: isOptionSet("arraysInObjects"),
+            objectsInObjectsException: isOptionSet("objectsInObjects"),
+            isOpeningCurlyBraceMustBeSpaced(_second) {
+                return options.spaced;
+            },
+            isClosingCurlyBraceMustBeSpaced(penultimate) {
+                var _a;
+                const targetPenultimateType = options.arraysInObjectsException && (0, ast_utils_1.isClosingBracketToken)(penultimate)
+                    ? "TOMLArray"
+                    : options.objectsInObjectsException &&
+                        (0, ast_utils_1.isClosingBraceToken)(penultimate)
+                        ? "TOMLInlineTable"
+                        : null;
+                return targetPenultimateType &&
+                    ((_a = sourceCode.getNodeByRangeIndex(penultimate.range[0])) === null || _a === void 0 ? void 0 : _a.type) ===
+                        targetPenultimateType
+                    ? !options.spaced
+                    : options.spaced;
             },
-            getNodeProxy: utils_1.convertESNode,
-        });
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function validateBraceSpacing(node, first, second, penultimate, last) {
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
+                if (options.isOpeningCurlyBraceMustBeSpaced(second)) {
+                    if (!firstSpaced)
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (firstSpaced && second.type !== "Block") {
+                        reportNoBeginningSpace(node, first);
+                    }
+                }
+            }
+            if ((0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
+                if (options.isClosingCurlyBraceMustBeSpaced(penultimate)) {
+                    if (!lastSpaced)
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (lastSpaced)
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        function getClosingBraceOfObject(node) {
+            const lastProperty = node.body[node.body.length - 1];
+            return sourceCode.getTokenAfter(lastProperty, ast_utils_1.isClosingBraceToken);
+        }
+        function checkForObject(node) {
+            if (node.body.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = getClosingBraceOfObject(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            validateBraceSpacing(node, first, second, penultimate, last);
+        }
+        return {
+            TOMLInlineTable: checkForObject,
+        };
     },
 });

package/lib/types.d.ts

@@ -114,7 +114,7 @@ export interface SourceCode {
     getTokenByRangeStart(offset: number, options?: {
         includeComments?: boolean;
     }): TOMLToken | null;
-    getFirstToken(node: AST.TOMLNode): AST.Token;
+    getFirstToken(node: AST.TOMLNode | AST.Token): AST.Token;
     getFirstToken(node: AST.TOMLNode, options?: CursorWithSkipOptions): TOMLToken | null;
     getFirstTokens(node: AST.TOMLNode, options?: CursorWithCountOptions): TOMLToken[];
     getLastToken(node: AST.TOMLNode): AST.Token;
@@ -186,7 +186,7 @@ export interface RuleFixer {
     remove(nodeOrToken: TOMLNodeOrToken): Fix;
     removeRange(range: AST.Range): Fix;
     replaceText(nodeOrToken: TOMLNodeOrToken, text: string): Fix;
-    replaceTextRange(range: AST.Range, text: string): Fix;
+    replaceTextRange(range: Readonly<AST.Range>, text: string): Fix;
 }
 export interface Fix {
     range: AST.Range;

package/lib/utils/ast-utils.d.ts

@@ -1,3 +1,10 @@
 import type { TOMLToken } from "../types";
+export declare const LINEBREAK_MATCHER: RegExp;
 export declare function isCommentToken(token: TOMLToken | null): boolean;
+export declare function isCommaToken(token: TOMLToken | null): token is TOMLToken;
 export declare function isEqualSign(token: TOMLToken | null): token is TOMLToken;
+export declare function isClosingParenToken(token: TOMLToken | null): token is TOMLToken;
+export declare const isNotClosingParenToken: typeof isClosingParenToken;
+export declare function isClosingBracketToken(token: TOMLToken | null): token is TOMLToken;
+export declare function isClosingBraceToken(token: TOMLToken | null): token is TOMLToken;
+export declare function isTokenOnSameLine(left: TOMLToken | null, right: TOMLToken | null): boolean;

package/lib/utils/ast-utils.js

@@ -1,11 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEqualSign = exports.isCommentToken = void 0;
+exports.isTokenOnSameLine = exports.isClosingBraceToken = exports.isClosingBracketToken = exports.isNotClosingParenToken = exports.isClosingParenToken = exports.isEqualSign = exports.isCommaToken = exports.isCommentToken = exports.LINEBREAK_MATCHER = void 0;
+exports.LINEBREAK_MATCHER = /\r\n|[\n\r\u2028\u2029]/u;
 function isCommentToken(token) {
     return Boolean(token && token.type === "Block");
 }
 exports.isCommentToken = isCommentToken;
+function isCommaToken(token) {
+    return token != null && token.value === "," && token.type === "Punctuator";
+}
+exports.isCommaToken = isCommaToken;
 function isEqualSign(token) {
     return token != null && token.type === "Punctuator" && token.value === "=";
 }
 exports.isEqualSign = isEqualSign;
+function isClosingParenToken(token) {
+    return token != null && token.value === ")" && token.type === "Punctuator";
+}
+exports.isClosingParenToken = isClosingParenToken;
+exports.isNotClosingParenToken = negate(isClosingParenToken);
+function isClosingBracketToken(token) {
+    return token != null && token.value === "]" && token.type === "Punctuator";
+}
+exports.isClosingBracketToken = isClosingBracketToken;
+function isClosingBraceToken(token) {
+    return token != null && token.value === "}" && token.type === "Punctuator";
+}
+exports.isClosingBraceToken = isClosingBraceToken;
+function isTokenOnSameLine(left, right) {
+    var _a, _b;
+    return ((_a = left === null || left === void 0 ? void 0 : left.loc) === null || _a === void 0 ? void 0 : _a.end.line) === ((_b = right === null || right === void 0 ? void 0 : right.loc) === null || _b === void 0 ? void 0 : _b.start.line);
+}
+exports.isTokenOnSameLine = isTokenOnSameLine;
+function negate(f) {
+    return ((token) => !f(token));
+}

package/lib/utils/index.d.ts

@@ -1,17 +1,2 @@
-import type { RuleListener, RuleModule, PartialRuleModule, RuleContext } from "../types";
-import type * as ESTree from "estree";
-import type { Rule } from "eslint";
-import type { AST } from "toml-eslint-parser";
+import type { RuleModule, PartialRuleModule } from "../types";
 export declare function createRule(ruleName: string, rule: PartialRuleModule): RuleModule;
-type CoreRuleListener = {
-    [key: string]: (node: any) => void;
-};
-export declare function defineWrapperListener(coreRule: Rule.RuleModule, context: RuleContext, proxyOptions: {
-    options: any[];
-    createListenerProxy?: (listener: CoreRuleListener) => RuleListener;
-    getNodeProxy?: (node: AST.TOMLNode) => any;
-}): RuleListener;
-export declare function getProxyNode(node: AST.TOMLNode, properties: any): any;
-export declare function convertESNode(node: AST.TOMLNode): ESTree.Node;
-export declare function getCoreRule(ruleName: string): Rule.RuleModule;
-export {};

package/lib/utils/index.js

@@ -26,12 +26,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCoreRule = exports.convertESNode = exports.getProxyNode = exports.defineWrapperListener = exports.createRule = void 0;
+exports.createRule = void 0;
 const tomlESLintParser = __importStar(require("toml-eslint-parser"));
-const debug_1 = __importDefault(require("debug"));
 const path_1 = __importDefault(require("path"));
 const compat_1 = require("./compat");
-const log = (0, debug_1.default)("eslint-plugin-toml:utils/index");
 function createRule(ruleName, rule) {
     return {
         meta: Object.assign(Object.assign({}, rule.meta), { docs: Object.assign(Object.assign({}, rule.meta.docs), { url: `https://ota-meshi.github.io/eslint-plugin-toml/rules/${ruleName}.html`, ruleId: `toml/${ruleName}`, ruleName }) }),
@@ -56,95 +54,3 @@ function createRule(ruleName, rule) {
     };
 }
 exports.createRule = createRule;
-function defineWrapperListener(coreRule, context, proxyOptions) {
-    var _a, _b;
-    const sourceCode = (0, compat_1.getSourceCode)(context);
-    if (!sourceCode.parserServices.isTOML) {
-        return {};
-    }
-    const proxySourceCode = Object.assign({ __proto__: sourceCode }, ["getNodeByRangeIndex"].reduce((obj, key) => {
-        obj[key] = (...args) => {
-            var _a;
-            const node = sourceCode[key](...args);
-            return ((_a = proxyOptions.getNodeProxy) === null || _a === void 0 ? void 0 : _a.call(proxyOptions, node)) || node;
-        };
-        return obj;
-    }, {}));
-    const listener = coreRule.create({
-        __proto__: context,
-        options: proxyOptions.options,
-        getSourceCode() {
-            return proxySourceCode;
-        },
-        sourceCode: proxySourceCode,
-    });
-    const tomlListener = (_b = (_a = proxyOptions.createListenerProxy) === null || _a === void 0 ? void 0 : _a.call(proxyOptions, listener)) !== null && _b !== void 0 ? _b : listener;
-    return tomlListener;
-}
-exports.defineWrapperListener = defineWrapperListener;
-function getProxyNode(node, properties) {
-    const safeKeys = new Set([
-        "range",
-        "typeAnnotation",
-    ]);
-    const cache = {};
-    return new Proxy(node, {
-        get(_t, key) {
-            if (key in cache) {
-                return cache[key];
-            }
-            if (key in properties) {
-                return (cache[key] = properties[key]);
-            }
-            if (!safeKeys.has(key)) {
-                log(`fallback: ${String(key)}`);
-            }
-            return node[key];
-        },
-    });
-}
-exports.getProxyNode = getProxyNode;
-const convertedESNodeCache = new WeakMap();
-function convertESNode(node) {
-    const converted = convertedESNodeCache.get(node);
-    if (converted) {
-        return converted;
-    }
-    let esNode;
-    if (node.type === "TOMLInlineTable") {
-        const properties = node.body;
-        esNode = getProxyNode(node, {
-            type: "ObjectExpression",
-            get properties() {
-                return properties.map(convertESNode);
-            },
-        });
-    }
-    else if (node.type === "TOMLArray") {
-        const elements = node.elements;
-        esNode = getProxyNode(node, {
-            type: "ArrayExpression",
-            get elements() {
-                return elements.map(convertESNode);
-            },
-        });
-    }
-    else {
-        esNode = node;
-    }
-    convertedESNodeCache.set(node, esNode);
-    return esNode;
-}
-exports.convertESNode = convertESNode;
-let ruleMap = null;
-function getCoreRule(ruleName) {
-    let map;
-    if (ruleMap) {
-        map = ruleMap;
-    }
-    else {
-        ruleMap = map = new (require("eslint").Linter)().getRules();
-    }
-    return map.get(ruleName);
-}
-exports.getCoreRule = getCoreRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-toml",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "This ESLint plugin provides linting rules for TOML.",
   "main": "lib/index.js",
   "files": [
@@ -59,10 +59,10 @@
     "debug": "^4.1.1",
     "eslint-compat-utils": "^0.1.2",
     "lodash": "^4.17.19",
-    "toml-eslint-parser": "^0.8.1"
+    "toml-eslint-parser": "^0.9.0"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.4.6",
+    "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.24.2",
     "@ota-meshi/eslint-plugin": "^0.15.0",
     "@ota-meshi/site-kit-eslint-editor-vue": "^0.1.2",
@@ -99,11 +99,11 @@
     "pako": "^2.1.0",
     "prettier": "^3.0.0",
     "semver": "^7.3.2",
-    "stylelint": "^15",
+    "stylelint": "^16.0.0",
     "stylelint-config-recommended-vue": "^1.0.0",
-    "stylelint-config-standard": "^34.0.0",
+    "stylelint-config-standard": "^35.0.0",
     "stylelint-config-standard-vue": "^1.0.0",
-    "stylelint-stylus": "^0.18.0",
+    "stylelint-stylus": "^1.0.0",
     "ts-node": "^10.0.0",
     "typescript": "~5.0.0",
     "vite-plugin-eslint4b": "^0.2.1",