eslint-plugin-better-tailwindcss 4.3.2 → 4.4.1

package/lib/rules/enforce-logical-properties.d.ts

@@ -0,0 +1,426 @@
+export declare const enforceLogicalProperties: {
+    category: "stylistic";
+    messages: {
+        readonly replaceable: "Physical class detected. Replace \"{{ className }}\" with logical class \"{{fix}}\".";
+    } | undefined;
+    name: "enforce-logical-properties";
+    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: "replaceable";
+        }>) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly replaceable: "Physical class detected. Replace \"{{ className }}\" with logical class \"{{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-logical-properties.d.ts.map

package/lib/rules/enforce-logical-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-logical-properties.d.ts","sourceRoot":"","sources":["../../src/rules/enforce-logical-properties.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBnC,CAAC"}

package/lib/rules/enforce-logical-properties.js

@@ -0,0 +1,118 @@
+import { createGetDissectedClasses, getDissectedClasses } from "../tailwindcss/dissect-classes.js";
+import { createGetUnknownClasses, getUnknownClasses } from "../tailwindcss/unknown-classes.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 { replacePlaceholders, splitClasses } from "../utils/utils.js";
+export const enforceLogicalProperties = createRule({
+    autofix: true,
+    category: "stylistic",
+    description: "Enforce logical property class names instead of physical directions.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/enforce-logical-properties.md",
+    name: "enforce-logical-properties",
+    recommended: false,
+    messages: {
+        replaceable: "Physical class detected. Replace \"{{ className }}\" with logical class \"{{fix}}\"."
+    },
+    initialize: ctx => {
+        createGetDissectedClasses(ctx);
+        createGetUnknownClasses(ctx);
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+const mappings = [
+    [/^pl-(.*)$/, "ps-$1"],
+    [/^pr-(.*)$/, "pe-$1"],
+    [/^pt-(.*)$/, "pbs-$1"],
+    [/^pb-(.*)$/, "pbe-$1"],
+    [/^ml-(.*)$/, "ms-$1"],
+    [/^mr-(.*)$/, "me-$1"],
+    [/^mt-(.*)$/, "mbs-$1"],
+    [/^mb-(.*)$/, "mbe-$1"],
+    [/^scroll-ml-(.*)$/, "scroll-ms-$1"],
+    [/^scroll-mr-(.*)$/, "scroll-me-$1"],
+    [/^scroll-pl-(.*)$/, "scroll-ps-$1"],
+    [/^scroll-pr-(.*)$/, "scroll-pe-$1"],
+    [/^scroll-mt-(.*)$/, "scroll-mbs-$1"],
+    [/^scroll-mb-(.*)$/, "scroll-mbe-$1"],
+    [/^scroll-pt-(.*)$/, "scroll-pbs-$1"],
+    [/^scroll-pb-(.*)$/, "scroll-pbe-$1"],
+    [/^left-(.*)$/, "inset-s-$1"],
+    [/^right-(.*)$/, "inset-e-$1"],
+    [/^top-(.*)$/, "inset-bs-$1"],
+    [/^bottom-(.*)$/, "inset-be-$1"],
+    [/^border-l$/, "border-s"],
+    [/^border-l-(.*)$/, "border-s-$1"],
+    [/^border-r$/, "border-e"],
+    [/^border-r-(.*)$/, "border-e-$1"],
+    [/^border-t$/, "border-bs"],
+    [/^border-t-(.*)$/, "border-bs-$1"],
+    [/^border-b$/, "border-be"],
+    [/^border-b-(.*)$/, "border-be-$1"],
+    [/^rounded-l$/, "rounded-s"],
+    [/^rounded-l-(.*)$/, "rounded-s-$1"],
+    [/^rounded-r$/, "rounded-e"],
+    [/^rounded-r-(.*)$/, "rounded-e-$1"],
+    [/^rounded-tl$/, "rounded-ss"],
+    [/^rounded-tl-(.*)$/, "rounded-ss-$1"],
+    [/^rounded-tr$/, "rounded-se"],
+    [/^rounded-tr-(.*)$/, "rounded-se-$1"],
+    [/^rounded-br$/, "rounded-ee"],
+    [/^rounded-br-(.*)$/, "rounded-ee-$1"],
+    [/^rounded-bl$/, "rounded-es"],
+    [/^rounded-bl-(.*)$/, "rounded-es-$1"],
+    [/^text-left$/, "text-start"],
+    [/^text-right$/, "text-end"],
+    [/^float-left$/, "float-start"],
+    [/^float-right$/, "float-end"],
+    [/^clear-left$/, "clear-start"],
+    [/^clear-right$/, "clear-end"]
+];
+function lintLiterals(ctx, literals) {
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { dissectedClasses, warnings } = getDissectedClasses(async(ctx), classes);
+        const possibleFixes = Object.values(dissectedClasses).flatMap(dissectedClass => {
+            const replacementBase = getReplacementBase(dissectedClass.base);
+            if (!replacementBase) {
+                return [];
+            }
+            return [buildClass(ctx, { ...dissectedClass, base: replacementBase })];
+        });
+        const { unknownClasses } = getUnknownClasses(async(ctx), possibleFixes);
+        lintClasses(ctx, literal, className => {
+            const dissectedClass = dissectedClasses[className];
+            if (!dissectedClass) {
+                return;
+            }
+            const replacementBase = getReplacementBase(dissectedClass.base);
+            if (!replacementBase) {
+                return;
+            }
+            const fix = buildClass(ctx, { ...dissectedClass, base: replacementBase });
+            if (unknownClasses.includes(fix)) {
+                return;
+            }
+            return {
+                data: {
+                    className,
+                    fix
+                },
+                fix,
+                id: "replaceable",
+                warnings
+            };
+        });
+    }
+}
+function getReplacementBase(base) {
+    for (const [pattern, replacement] of mappings) {
+        const match = base.match(pattern);
+        if (!match) {
+            continue;
+        }
+        return replacePlaceholders(replacement, match);
+    }
+}
+//# sourceMappingURL=enforce-logical-properties.js.map

package/lib/rules/enforce-logical-properties.js.map

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