eslint-plugin-better-tailwindcss 4.3.2 → 4.4.1

package/lib/rules/enforce-consistent-variant-order.d.ts

@@ -0,0 +1,426 @@
+export declare const enforceConsistentVariantOrder: {
+    category: "stylistic";
+    messages: {
+        readonly order: "Incorrect variant order. '{{ className }}' should be '{{ fix }}'.";
+    } | undefined;
+    name: "enforce-consistent-variant-order";
+    readonly options: {
+        cwd?: string | undefined;
+        rootFontSize?: number | undefined;
+        detectComponentClasses: boolean;
+        tsconfig?: string | undefined;
+        tailwindConfig?: string | undefined;
+        messageStyle: "visual" | "compact" | "raw";
+        entryPoint?: string | undefined;
+        tags?: (string | [string, ({
+            match: import("../types/rule.js").MatcherType.String;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectKey;
+            pathPattern?: string | undefined;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectValue;
+            pathPattern?: string | undefined;
+        })[]])[] | undefined;
+        variables?: (string | [string, ({
+            match: import("../types/rule.js").MatcherType.String;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectKey;
+            pathPattern?: string | undefined;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectValue;
+            pathPattern?: string | undefined;
+        })[]])[] | undefined;
+        attributes?: (string | [string, ({
+            match: import("../types/rule.js").MatcherType.String;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectKey;
+            pathPattern?: string | undefined;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectValue;
+            pathPattern?: string | undefined;
+        })[]])[] | undefined;
+        callees?: (string | [string, ({
+            match: import("../types/rule.js").MatcherType.String;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectKey;
+            pathPattern?: string | undefined;
+        } | {
+            match: import("../types/rule.js").MatcherType.ObjectValue;
+            pathPattern?: string | undefined;
+        })[]])[] | undefined;
+        selectors: ({
+            callTarget?: number | "all" | "first" | "last" | undefined;
+            kind: import("../types/rule.js").SelectorKind.Callee;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name: string;
+            path?: string | undefined;
+            targetArgument?: number | "all" | "first" | "last" | undefined;
+            targetCall?: number | "all" | "first" | "last" | undefined;
+        } | {
+            callTarget?: number | "all" | "first" | "last" | undefined;
+            kind: import("../types/rule.js").SelectorKind.Callee;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name?: string | undefined;
+            path: string;
+            targetArgument?: number | "all" | "first" | "last" | undefined;
+            targetCall?: number | "all" | "first" | "last" | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name: string;
+            path?: string | undefined;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Tag;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name?: string | undefined;
+            path: string;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Attribute;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name: string;
+        } | {
+            kind: import("../types/rule.js").SelectorKind.Variable;
+            match?: ({
+                type: import("../types/rule.js").MatcherType.String;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectKey;
+            } | {
+                path?: string | undefined;
+                type: import("../types/rule.js").MatcherType.ObjectValue;
+            } | {
+                match: ({
+                    type: import("../types/rule.js").MatcherType.String;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectKey;
+                } | {
+                    path?: string | undefined;
+                    type: import("../types/rule.js").MatcherType.ObjectValue;
+                })[];
+                type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+            })[] | undefined;
+            name: string;
+        })[];
+    } & {
+        [x: string]: unknown;
+    };
+    recommended: false;
+    rule: {
+        create: (ctx: import("node_modules/@eslint/core/dist/cjs/types.cjs").RuleContext<{
+            LangOptions: import("eslint").Linter.LanguageOptions;
+            Code: import("eslint").SourceCode;
+            RuleOptions: [Required<{
+                cwd?: string | undefined;
+                rootFontSize?: number | undefined;
+                detectComponentClasses: boolean;
+                tsconfig?: string | undefined;
+                tailwindConfig?: string | undefined;
+                messageStyle: "visual" | "compact" | "raw";
+                entryPoint?: string | undefined;
+                tags?: (string | [string, ({
+                    match: import("../types/rule.js").MatcherType.String;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectKey;
+                    pathPattern?: string | undefined;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectValue;
+                    pathPattern?: string | undefined;
+                })[]])[] | undefined;
+                variables?: (string | [string, ({
+                    match: import("../types/rule.js").MatcherType.String;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectKey;
+                    pathPattern?: string | undefined;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectValue;
+                    pathPattern?: string | undefined;
+                })[]])[] | undefined;
+                attributes?: (string | [string, ({
+                    match: import("../types/rule.js").MatcherType.String;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectKey;
+                    pathPattern?: string | undefined;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectValue;
+                    pathPattern?: string | undefined;
+                })[]])[] | undefined;
+                callees?: (string | [string, ({
+                    match: import("../types/rule.js").MatcherType.String;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectKey;
+                    pathPattern?: string | undefined;
+                } | {
+                    match: import("../types/rule.js").MatcherType.ObjectValue;
+                    pathPattern?: string | undefined;
+                })[]])[] | undefined;
+                selectors: ({
+                    callTarget?: number | "all" | "first" | "last" | undefined;
+                    kind: import("../types/rule.js").SelectorKind.Callee;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name: string;
+                    path?: string | undefined;
+                    targetArgument?: number | "all" | "first" | "last" | undefined;
+                    targetCall?: number | "all" | "first" | "last" | undefined;
+                } | {
+                    callTarget?: number | "all" | "first" | "last" | undefined;
+                    kind: import("../types/rule.js").SelectorKind.Callee;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name?: string | undefined;
+                    path: string;
+                    targetArgument?: number | "all" | "first" | "last" | undefined;
+                    targetCall?: number | "all" | "first" | "last" | undefined;
+                } | {
+                    kind: import("../types/rule.js").SelectorKind.Tag;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name: string;
+                    path?: string | undefined;
+                } | {
+                    kind: import("../types/rule.js").SelectorKind.Tag;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name?: string | undefined;
+                    path: string;
+                } | {
+                    kind: import("../types/rule.js").SelectorKind.Attribute;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name: string;
+                } | {
+                    kind: import("../types/rule.js").SelectorKind.Variable;
+                    match?: ({
+                        type: import("../types/rule.js").MatcherType.String;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectKey;
+                    } | {
+                        path?: string | undefined;
+                        type: import("../types/rule.js").MatcherType.ObjectValue;
+                    } | {
+                        match: ({
+                            type: import("../types/rule.js").MatcherType.String;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectKey;
+                        } | {
+                            path?: string | undefined;
+                            type: import("../types/rule.js").MatcherType.ObjectValue;
+                        })[];
+                        type: import("../types/rule.js").MatcherType.AnonymousFunctionReturn;
+                    })[] | undefined;
+                    name: string;
+                })[];
+            } & {
+                [x: string]: unknown;
+            }>];
+            Node: import("eslint").JSSyntaxElement;
+            MessageIds: "order";
+        }>) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly order: "Incorrect variant order. '{{ className }}' should be '{{ fix }}'.";
+            };
+            docs: {
+                description: string;
+                recommended: boolean;
+                url: string;
+            };
+            fixable: "code" | undefined;
+            schema: {
+                additionalProperties: false;
+                properties: Record<string, boolean | import("@valibot/to-json-schema").JsonSchema> | undefined;
+                type: "object";
+            }[];
+            type: "problem" | "layout";
+        };
+    };
+};
+//# sourceMappingURL=enforce-consistent-variant-order.d.ts.map

package/lib/rules/enforce-consistent-variant-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-consistent-variant-order.d.ts","sourceRoot":"","sources":["../../src/rules/enforce-consistent-variant-order.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoExC,CAAC"}

package/lib/rules/enforce-consistent-variant-order.js

@@ -0,0 +1,75 @@
+import { createGetDissectedClasses, getDissectedClasses } from "../tailwindcss/dissect-classes.js";
+import { createGetVariantOrder, getVariantOrder } from "../tailwindcss/variant-order.js";
+import { buildClass } from "../utils/class.js";
+import { async } from "../utils/context.js";
+import { lintClasses } from "../utils/lint.js";
+import { createRule } from "../utils/rule.js";
+import { splitClasses } from "../utils/utils.js";
+export const enforceConsistentVariantOrder = createRule({
+    autofix: true,
+    category: "stylistic",
+    description: "Enforce a consistent variant order for Tailwind classes.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/enforce-consistent-variant-order.md",
+    name: "enforce-consistent-variant-order",
+    recommended: false,
+    messages: {
+        order: "Incorrect variant order. '{{ className }}' should be '{{ fix }}'."
+    },
+    initialize: ctx => {
+        createGetDissectedClasses(ctx);
+        createGetVariantOrder(ctx);
+    },
+    lintLiterals: (ctx, literals) => {
+        if (ctx.version.major <= 3) {
+            return;
+        }
+        for (const literal of literals) {
+            const classes = splitClasses(literal.content);
+            const { dissectedClasses, warnings: dissectedWarnings } = getDissectedClasses(async(ctx), classes);
+            const { variantOrder, warnings } = getVariantOrder(async(ctx), classes);
+            const allWarnings = [...dissectedWarnings, ...warnings];
+            lintClasses(ctx, literal, className => {
+                const dissectedClass = dissectedClasses[className];
+                if (!dissectedClass?.variants || dissectedClass.variants.length <= 1) {
+                    return;
+                }
+                if (dissectedClass.variants.some(variant => variantOrder[variant] === undefined)) {
+                    return;
+                }
+                const sortedVariants = dissectedClass.variants.toSorted((variantA, variantB) => {
+                    return compareVariantOrder(variantOrder[variantA], variantOrder[variantB]);
+                });
+                if (dissectedClass.variants.every((value, index) => value === sortedVariants[index])) {
+                    return false;
+                }
+                const fix = buildClass(ctx, {
+                    ...dissectedClass,
+                    variants: sortedVariants
+                });
+                return {
+                    data: {
+                        className,
+                        fix
+                    },
+                    fix,
+                    id: "order",
+                    warnings: allWarnings
+                };
+            });
+        }
+    }
+});
+function compareVariantOrder(orderA, orderB) {
+    if (orderA === orderB) {
+        return 0;
+    }
+    if (orderA === undefined) {
+        return +1;
+    }
+    if (orderB === undefined) {
+        return -1;
+    }
+    // Match Tailwind language service behavior: variants with higher order index come first.
+    return +(orderB - orderA > 0) - +(orderB - orderA < 0);
+}
+//# sourceMappingURL=enforce-consistent-variant-order.js.map

package/lib/rules/enforce-consistent-variant-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-consistent-variant-order.js","sourceRoot":"","sources":["../../src/rules/enforce-consistent-variant-order.ts"],"names":[],"mappings":"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"}