@dhzh/eslint-plugin-better-tailwindcss 0.0.0-stage → 4.9.0-patch

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

@@ -0,0 +1,77 @@
+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 { VARIANT_ORDER_FLAGS } from "../async-utils/order.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;
+        }
+        const asyncCtx = async(ctx);
+        for (const literal of literals) {
+            const classes = splitClasses(literal.content);
+            const { dissectedClasses, warnings: dissectedWarnings } = getDissectedClasses(asyncCtx, classes);
+            const { variantOrder, warnings } = getVariantOrder(asyncCtx, 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 ||
+        orderA === undefined ||
+        orderB === undefined ||
+        orderA < VARIANT_ORDER_FLAGS.GLOBAL &&
+            orderB < VARIANT_ORDER_FLAGS.GLOBAL) {
+        return 0;
+    }
+    if (orderB > orderA) {
+        return +1;
+    }
+    return -1;
+}
+//# 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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"}

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

@@ -0,0 +1,227 @@
+export declare const enforceLogicalProperties: {
+    category: "stylistic";
+    messages: {
+        readonly multiple: "Physical class detected. Replace \"{{ className }}\" with logical classes \"{{fix}}\".";
+        readonly single: "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;
+        })[];
+    } & {
+        ignore: string[];
+    };
+    recommended: false;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly multiple: "Physical class detected. Replace \"{{ className }}\" with logical classes \"{{fix}}\".";
+                readonly single: "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":"AAeA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BnC,CAAC"}

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

@@ -0,0 +1,142 @@
+import { array, description, optional, pipe, strictObject, string } from "valibot";
+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 { getCachedRegex } from "../async-utils/regex.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,
+    schema: strictObject({
+        ignore: optional(pipe(array(string()), description("A list of regular expression patterns for classes that should be ignored by the rule.")), [])
+    }),
+    messages: {
+        multiple: "Physical class detected. Replace \"{{ className }}\" with logical classes \"{{fix}}\".",
+        single: "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"],
+    [/^h-(.*)$/, "block-$1"],
+    [/^w-(.*)$/, "inline-$1"],
+    [/^min-h-(.*)$/, "min-block-$1"],
+    [/^min-w-(.*)$/, "min-inline-$1"],
+    [/^max-h-(.*)$/, "max-block-$1"],
+    [/^max-w-(.*)$/, "max-inline-$1"],
+    [/^size-(.*)$/, ["block-$1", "inline-$1"]]
+];
+function lintLiterals(ctx, literals) {
+    const { ignore } = ctx.options;
+    const ignoredClassRegexes = ignore.map(ignoredClass => getCachedRegex(ignoredClass));
+    const asyncCtx = async(ctx);
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { dissectedClasses, warnings } = getDissectedClasses(asyncCtx, classes);
+        const possibleFixes = Object.values(dissectedClasses).flatMap(dissectedClass => {
+            const replacementBases = getReplacementBases(dissectedClass.base);
+            if (!replacementBases) {
+                return [];
+            }
+            return replacementBases.map(base => buildClass(ctx, { ...dissectedClass, base }));
+        });
+        const { unknownClasses } = getUnknownClasses(asyncCtx, possibleFixes);
+        lintClasses(ctx, literal, className => {
+            if (ignoredClassRegexes.some(ignoredClassRegex => ignoredClassRegex.test(className))) {
+                return;
+            }
+            const dissectedClass = dissectedClasses[className];
+            if (!dissectedClass) {
+                return;
+            }
+            const replacementBases = getReplacementBases(dissectedClass.base);
+            if (!replacementBases) {
+                return;
+            }
+            const fixClasses = replacementBases.map(base => buildClass(ctx, { ...dissectedClass, base }));
+            const hasUnknownFix = fixClasses.some(fixClass => unknownClasses.includes(fixClass));
+            if (hasUnknownFix) {
+                return;
+            }
+            const fix = fixClasses.join(" ");
+            const id = fixClasses.length > 1 ? "multiple" : "single";
+            return {
+                data: {
+                    className,
+                    fix
+                },
+                fix,
+                id,
+                warnings
+            };
+        });
+    }
+}
+function getReplacementBases(base) {
+    for (const [pattern, replacement] of mappings) {
+        const match = base.match(pattern);
+        if (!match) {
+            continue;
+        }
+        return Array.isArray(replacement)
+            ? replacement.map(part => replacePlaceholders(part, match))
+            : [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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"}