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

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

@@ -0,0 +1,225 @@
+export declare const noConcatenatedClasses: {
+    category: "correctness";
+    messages: {
+        readonly concatenated: "Concatenated classes may be purged by Tailwind CSS. Avoid dynamic class construction.";
+    } | undefined;
+    name: "no-concatenated-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 concatenated: "Concatenated classes may be purged by Tailwind CSS. Avoid dynamic class construction.";
+            };
+            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-concatenated-classes.d.ts.map

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

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

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

@@ -0,0 +1,31 @@
+import { lintClasses } from "../utils/lint.js";
+import { createRule } from "../utils/rule.js";
+import { isConcatenatedLeft, isConcatenatedLiteral, isConcatenatedRight } from "../utils/utils.js";
+export const noConcatenatedClasses = createRule({
+    autofix: false,
+    category: "correctness",
+    description: "Disallow concatenated classes in Tailwind CSS class strings.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-concatenated-classes.md",
+    name: "no-concatenated-classes",
+    recommended: true,
+    messages: {
+        concatenated: "Concatenated classes may be purged by Tailwind CSS. Avoid dynamic class construction."
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    for (const literal of literals) {
+        if (!isConcatenatedLiteral(literal)) {
+            continue;
+        }
+        lintClasses(ctx, literal, (_, index, classes) => {
+            if (index === 0 && isConcatenatedLeft(literal) ||
+                index === classes.length - 1 && isConcatenatedRight(literal)) {
+                return {
+                    id: "concatenated"
+                };
+            }
+        });
+    }
+}
+//# sourceMappingURL=no-concatenated-classes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-concatenated-classes.js","sourceRoot":"","sources":["../../src/rules/no-concatenated-classes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAMnH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;IAC9C,OAAO,EAAE,KAAK;IACd,QAAQ,EAAE,aAAa;IACvB,WAAW,EAAE,8DAA8D;IAC3E,IAAI,EAAE,6GAA6G;IACnH,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EAAE,IAAI;IAEjB,QAAQ,EAAE;QACR,YAAY,EAAE,uFAAuF;KACtG;IAED,YAAY,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC;CAC7D,CAAC,CAAC;AAGH,SAAS,YAAY,CAAC,GAA0C,EAAE,QAAmB;IACnF,KAAI,MAAM,OAAO,IAAI,QAAQ,EAAC,CAAC;QAC7B,IAAG,CAAC,qBAAqB,CAAC,OAAO,CAAC,EAAC,CAAC;YAClC,SAAS;QACX,CAAC;QAED,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YAC9C,IACE,KAAK,KAAK,CAAC,IAAI,kBAAkB,CAAC,OAAO,CAAC;gBAC1C,KAAK,KAAK,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,mBAAmB,CAAC,OAAO,CAAC,EAC7D,CAAC;gBACA,OAAO;oBACL,EAAE,EAAE,cAAc;iBACV,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,225 @@
+export declare const noConflictingClasses: {
+    category: "correctness";
+    messages: {
+        readonly conflicting: "Conflicting class detected: \"{{ className }}\" and \"{{ conflictingClassString }}\" apply the same CSS properties: \"{{ conflictingPropertiesString }}\".";
+    } | undefined;
+    name: "no-conflicting-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 conflicting: "Conflicting class detected: \"{{ className }}\" and \"{{ conflictingClassString }}\" apply the same CSS properties: \"{{ conflictingPropertiesString }}\".";
+            };
+            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-conflicting-classes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-conflicting-classes.d.ts","sourceRoot":"","sources":["../../src/rules/no-conflicting-classes.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB/B,CAAC"}

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

@@ -0,0 +1,60 @@
+import { createGetConflictingClasses, getConflictingClasses } from "../tailwindcss/conflicting-classes.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 noConflictingClasses = createRule({
+    autofix: true,
+    category: "correctness",
+    description: "Disallow classes that produce conflicting styles.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-conflicting-classes.md",
+    name: "no-conflicting-classes",
+    recommended: true,
+    messages: {
+        conflicting: "Conflicting class detected: \"{{ className }}\" and \"{{ conflictingClassString }}\" apply the same CSS properties: \"{{ conflictingPropertiesString }}\"."
+    },
+    initialize(ctx) {
+        createGetConflictingClasses(ctx);
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    const asyncCtx = async(ctx);
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { conflictingClasses, warnings } = getConflictingClasses(asyncCtx, classes);
+        if (Object.keys(conflictingClasses).length === 0) {
+            continue;
+        }
+        lintClasses(ctx, literal, className => {
+            if (!conflictingClasses[className]) {
+                return;
+            }
+            const conflicts = Object.entries(conflictingClasses[className]);
+            if (conflicts.length === 0) {
+                return;
+            }
+            const conflictingClassNames = conflicts.map(([conflictingClassName]) => conflictingClassName);
+            const conflictingProperties = conflicts.reduce((acc, [, properties]) => {
+                for (const property of properties) {
+                    if (!acc.includes(property.cssPropertyName)) {
+                        acc.push(property.cssPropertyName);
+                    }
+                }
+                return acc;
+            }, []);
+            const conflictingClassString = conflictingClassNames.join(", ");
+            const conflictingPropertiesString = conflictingProperties.map(conflictingProperty => `"${conflictingProperty}"`).join(", ");
+            return {
+                data: {
+                    className,
+                    conflictingClassString,
+                    conflictingPropertiesString
+                },
+                id: "conflicting",
+                warnings
+            };
+        });
+    }
+}
+//# sourceMappingURL=no-conflicting-classes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-conflicting-classes.js","sourceRoot":"","sources":["../../src/rules/no-conflicting-classes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACtB,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,qCAAqC,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAMjE,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;IAC7C,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,aAAa;IACvB,WAAW,EAAE,mDAAmD;IAChE,IAAI,EAAE,4GAA4G;IAClH,IAAI,EAAE,wBAAwB;IAC9B,WAAW,EAAE,IAAI;IAEjB,QAAQ,EAAE;QACR,WAAW,EAAE,4JAA4J;KAC1K;IAED,UAAU,CAAC,GAAG;QACZ,2BAA2B,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,YAAY,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC;CAC7D,CAAC,CAAC;AAEH,SAAS,YAAY,CAAC,GAAyC,EAAE,QAAmB;IAElF,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IAE5B,KAAI,MAAM,OAAO,IAAI,QAAQ,EAAC,CAAC;QAE7B,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAE9C,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,GAAG,qBAAqB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAElF,IAAG,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,MAAM,KAAK,CAAC,EAAC,CAAC;YAC/C,SAAS;QACX,CAAC;QAED,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE;YACpC,IAAG,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAC,CAAC;gBACjC,OAAO;YACT,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;YAEhE,IAAG,SAAS,CAAC,MAAM,KAAK,CAAC,EAAC,CAAC;gBACzB,OAAO;YACT,CAAC;YAED,MAAM,qBAAqB,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,oBAAoB,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,CAAC;YAC9F,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,CAAW,CAAC,GAAG,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,EAAE;gBAC/E,KAAI,MAAM,QAAQ,IAAI,UAAU,EAAC,CAAC;oBAChC,IAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAC,CAAC;wBAC1C,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;oBACrC,CAAC;gBACH,CAAC;gBACD,OAAO,GAAG,CAAC;YACb,CAAC,EAAE,EAAE,CAAC,CAAC;YAEP,MAAM,sBAAsB,GAAG,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChE,MAAM,2BAA2B,GAAG,qBAAqB,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,CAAC,IAAI,mBAAmB,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAE5H,OAAO;gBACL,IAAI,EAAE;oBACJ,SAAS;oBACT,sBAAsB;oBACtB,2BAA2B;iBAC5B;gBACD,EAAE,EAAE,aAAa;gBACjB,QAAQ;aACA,CAAC;QAEb,CAAC,CAAC,CAAC;IAEL,CAAC;AACH,CAAC"}