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

package/lib/rules/no-deprecated-classes.d.ts

@@ -0,0 +1,227 @@
+export declare const noDeprecatedClasses: {
+    category: "stylistic";
+    messages: {
+        readonly irreplaceable: "Class \"{{ className }}\" is deprecated. Check the tailwindcss documentation for more information: https://tailwindcss.com/docs/upgrade-guide#removed-deprecated-utilities";
+        readonly replaceable: "Deprecated class detected. Replace \"{{ className }}\" with \"{{fix}}\".";
+    } | undefined;
+    name: "no-deprecated-classes";
+    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: true;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly irreplaceable: "Class \"{{ className }}\" is deprecated. Check the tailwindcss documentation for more information: https://tailwindcss.com/docs/upgrade-guide#removed-deprecated-utilities";
+                readonly replaceable: "Deprecated class detected. Replace \"{{ className }}\" with \"{{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=no-deprecated-classes.d.ts.map

package/lib/rules/no-deprecated-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-deprecated-classes.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated-classes.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB9B,CAAC"}

package/lib/rules/no-deprecated-classes.js

@@ -0,0 +1,103 @@
+import { createGetDissectedClasses, getDissectedClasses } from "../tailwindcss/dissect-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 noDeprecatedClasses = createRule({
+    autofix: true,
+    category: "stylistic",
+    description: "Disallow the use of deprecated Tailwind CSS classes.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-deprecated-classes.md",
+    name: "no-deprecated-classes",
+    recommended: true,
+    messages: {
+        irreplaceable: "Class \"{{ className }}\" is deprecated. Check the tailwindcss documentation for more information: https://tailwindcss.com/docs/upgrade-guide#removed-deprecated-utilities",
+        replaceable: "Deprecated class detected. Replace \"{{ className }}\" with \"{{fix}}\"."
+    },
+    initialize: ctx => {
+        createGetDissectedClasses(ctx);
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+const deprecations = [
+    [
+        { major: 4, minor: 0 }, [
+            [/^shadow$/, "shadow-sm"],
+            [/^inset-shadow$/, "inset-shadow-sm"],
+            [/^drop-shadow$/, "drop-shadow-sm"],
+            [/^blur$/, "blur-sm"],
+            [/^backdrop-blur$/, "backdrop-blur-sm"],
+            [/^rounded$/, "rounded-sm"],
+            [/^bg-opacity-(.*)$/],
+            [/^text-opacity-(.*)$/],
+            [/^border-opacity-(.*)$/],
+            [/^divide-opacity-(.*)$/],
+            [/^ring-opacity-(.*)$/],
+            [/^placeholder-opacity-(.*)$/],
+            [/^flex-shrink$/, "shrink"],
+            [/^flex-shrink-(.*)$/, "shrink-$1"],
+            [/^flex-grow$/, "grow"],
+            [/^flex-grow-(.*)$/, "grow-$1"],
+            [/^overflow-ellipsis$/, "text-ellipsis"],
+            [/^decoration-slice$/, "box-decoration-slice"],
+            [/^decoration-clone$/, "box-decoration-clone"]
+        ]
+    ], [
+        { major: 4, minor: 1 }, [
+            [/^bg-left-top$/, "bg-top-left"],
+            [/^bg-left-bottom$/, "bg-bottom-left"],
+            [/^bg-right-top$/, "bg-top-right"],
+            [/^bg-right-bottom$/, "bg-bottom-right"],
+            [/^object-left-top$/, "object-top-left"],
+            [/^object-left-bottom$/, "object-bottom-left"],
+            [/^object-right-top$/, "object-top-right"],
+            [/^object-right-bottom$/, "object-bottom-right"]
+        ]
+    ]
+];
+function lintLiterals(ctx, literals) {
+    const { major, minor } = ctx.version;
+    const asyncCtx = async(ctx);
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { dissectedClasses, warnings } = getDissectedClasses(asyncCtx, classes);
+        lintClasses(ctx, literal, className => {
+            const dissectedClass = dissectedClasses[className];
+            if (!dissectedClass) {
+                return;
+            }
+            for (const [version, deprecation] of deprecations) {
+                if (major < version.major || major === version.major && minor < version.minor) {
+                    continue;
+                }
+                for (const [pattern, replacement] of deprecation) {
+                    const match = dissectedClass.base.match(pattern);
+                    if (!match) {
+                        continue;
+                    }
+                    if (!replacement) {
+                        return {
+                            data: {
+                                className
+                            },
+                            id: "irreplaceable",
+                            warnings
+                        };
+                    }
+                    const fix = buildClass(ctx, { ...dissectedClass, base: replacePlaceholders(replacement, match) });
+                    return {
+                        data: {
+                            className,
+                            fix
+                        },
+                        fix,
+                        id: "replaceable",
+                        warnings
+                    };
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=no-deprecated-classes.js.map

package/lib/rules/no-deprecated-classes.js.map

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

package/lib/rules/no-duplicate-classes.d.ts

@@ -0,0 +1,225 @@
+export declare const noDuplicateClasses: {
+    category: "stylistic";
+    messages: {
+        readonly duplicate: "Duplicate classname: \"{{ className }}\".";
+    } | undefined;
+    name: "no-duplicate-classes";
+    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: true;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly duplicate: "Duplicate classname: \"{{ className }}\".";
+            };
+            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=no-duplicate-classes.d.ts.map

package/lib/rules/no-duplicate-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-duplicate-classes.d.ts","sourceRoot":"","sources":["../../src/rules/no-duplicate-classes.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa7B,CAAC"}

package/lib/rules/no-duplicate-classes.js

@@ -0,0 +1,52 @@
+import { lintClasses } from "../utils/lint.js";
+import { createRule } from "../utils/rule.js";
+import { isClassSticky, splitClasses } from "../utils/utils.js";
+export const noDuplicateClasses = createRule({
+    autofix: true,
+    category: "stylistic",
+    description: "Disallow duplicate class names in tailwind classes.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-duplicate-classes.md",
+    name: "no-duplicate-classes",
+    recommended: true,
+    messages: {
+        duplicate: "Duplicate classname: \"{{ className }}\"."
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    for (const literal of literals) {
+        const parentClasses = literal.priorLiterals
+            ? getClassesFromLiteralNodes(literal.priorLiterals)
+            : [];
+        lintClasses(ctx, literal, (className, index, _, after) => {
+            const duplicateClassIndex = after.findIndex((afterClass, afterIndex) => afterClass === className && afterIndex < index);
+            // always keep sticky classes
+            if (isClassSticky(literal, index) || isClassSticky(literal, duplicateClassIndex)) {
+                return;
+            }
+            if (parentClasses.includes(className) || duplicateClassIndex !== -1) {
+                return {
+                    data: { className },
+                    fix: "",
+                    id: "duplicate"
+                };
+            }
+        });
+    }
+}
+function getClassesFromLiteralNodes(literals) {
+    return literals.reduce((combinedClasses, literal) => {
+        if (!literal) {
+            return combinedClasses;
+        }
+        const classes = literal.content;
+        const split = splitClasses(classes);
+        for (const className of split) {
+            if (!combinedClasses.includes(className)) {
+                combinedClasses.push(className);
+            }
+        }
+        return combinedClasses;
+    }, []);
+}
+//# sourceMappingURL=no-duplicate-classes.js.map

package/lib/rules/no-duplicate-classes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-duplicate-classes.js","sourceRoot":"","sources":["../../src/rules/no-duplicate-classes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAMhF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;IAC3C,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,qDAAqD;IAClE,IAAI,EAAE,0GAA0G;IAChH,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE,IAAI;IAEjB,QAAQ,EAAE;QACR,SAAS,EAAE,2CAA2C;KACvD;IAED,YAAY,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC;CAC7D,CAAC,CAAC;AAGH,SAAS,YAAY,CAAC,GAAuC,EAAE,QAAmB;IAChF,KAAI,MAAM,OAAO,IAAI,QAAQ,EAAC,CAAC;QAE7B,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa;YACzC,CAAC,CAAC,0BAA0B,CAAC,OAAO,CAAC,aAAa,CAAC;YACnD,CAAC,CAAC,EAAE,CAAC;QAEP,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE;YAEvD,MAAM,mBAAmB,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,KAAK,SAAS,IAAI,UAAU,GAAG,KAAK,CAAC,CAAC;YAExH,6BAA6B;YAC7B,IAAG,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,aAAa,CAAC,OAAO,EAAE,mBAAmB,CAAC,EAAC,CAAC;gBAC/E,OAAO;YACT,CAAC;YAED,IAAG,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,mBAAmB,KAAK,CAAC,CAAC,EAAC,CAAC;gBAClE,OAAO;oBACL,IAAI,EAAE,EAAE,SAAS,EAAE;oBACnB,GAAG,EAAE,EAAE;oBACP,EAAE,EAAE,WAAW;iBACP,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,SAAS,0BAA0B,CAAC,QAAmB;IACrD,OAAO,QAAQ,CAAC,MAAM,CAAW,CAAC,eAAe,EAAE,OAAO,EAAE,EAAE;QAC5D,IAAG,CAAC,OAAO,EAAC,CAAC;YAAC,OAAO,eAAe,CAAC;QAAC,CAAC;QAEvC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QAEpC,KAAI,MAAM,SAAS,IAAI,KAAK,EAAC,CAAC;YAC5B,IAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAC,CAAC;gBACvC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,OAAO,eAAe,CAAC;IAEzB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC"}