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

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

@@ -0,0 +1,225 @@
+export declare const noRestrictedClasses: {
+    category: "correctness";
+    messages: Record<string, string> | undefined;
+    name: "no-restricted-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;
+        })[];
+    } & {
+        restrict: (string | {
+            fix?: string | undefined;
+            message?: string | undefined;
+            pattern: string;
+        })[];
+    };
+    recommended: false;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: Record<string, string>;
+            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-restricted-classes.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+import { array, description, optional, pipe, strictObject, string, union } from "valibot";
+import { lintClasses } from "../utils/lint.js";
+import { createRule } from "../utils/rule.js";
+import { replacePlaceholders } from "../utils/utils.js";
+export const noRestrictedClasses = createRule({
+    autofix: true,
+    category: "correctness",
+    description: "Disallow restricted classes.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-restricted-classes.md",
+    name: "no-restricted-classes",
+    recommended: false,
+    schema: strictObject({
+        restrict: optional(array(union([
+            strictObject({
+                fix: optional(pipe(string(), description("A replacement class"))),
+                message: optional(pipe(string(), description("The message to report when a class is restricted."))),
+                pattern: pipe(string(), description("The regex pattern to match restricted classes."))
+            }),
+            string()
+        ])), [])
+    }),
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    const { restrict: restrictions } = ctx.options;
+    for (const literal of literals) {
+        lintClasses(ctx, literal, className => {
+            for (const restriction of restrictions) {
+                const pattern = typeof restriction === "string"
+                    ? restriction
+                    : restriction.pattern;
+                const matches = className.match(pattern);
+                if (!matches) {
+                    continue;
+                }
+                const message = typeof restriction === "string" || !restriction.message
+                    ? `Restricted class: "${className}".`
+                    : replacePlaceholders(restriction.message, matches);
+                if (typeof restriction === "string") {
+                    return {
+                        message
+                    };
+                }
+                if (restriction.fix !== undefined) {
+                    return {
+                        fix: replacePlaceholders(restriction.fix, matches),
+                        message
+                    };
+                }
+                return {
+                    message
+                };
+            }
+        });
+    }
+}
+//# sourceMappingURL=no-restricted-classes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-restricted-classes.js","sourceRoot":"","sources":["../../src/rules/no-restricted-classes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,WAAW,EACX,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,KAAK,EACN,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAMxE,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAC5C,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,aAAa;IACvB,WAAW,EAAE,8BAA8B;IAC3C,IAAI,EAAE,2GAA2G;IACjH,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,KAAK;IAElB,MAAM,EAAE,YAAY,CAAC;QACnB,QAAQ,EAAE,QAAQ,CAChB,KAAK,CACH,KAAK,CAAC;YACJ,YAAY,CACV;gBACE,GAAG,EAAE,QAAQ,CACX,IAAI,CACF,MAAM,EAAE,EACR,WAAW,CAAC,qBAAqB,CAAC,CACnC,CACF;gBACD,OAAO,EAAE,QAAQ,CACf,IAAI,CACF,MAAM,EAAE,EACR,WAAW,CAAC,mDAAmD,CAAC,CACjE,CACF;gBACD,OAAO,EAAE,IAAI,CACX,MAAM,EAAE,EACR,WAAW,CAAC,gDAAgD,CAAC,CAC9D;aACF,CACF;YACD,MAAM,EAAE;SACT,CAAC,CACH,EACD,EAAE,CACH;KACF,CAAC;IAEF,YAAY,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC;CAC7D,CAAC,CAAC;AAGH,SAAS,YAAY,CAAC,GAAwC,EAAE,QAAmB;IAEjF,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC;IAE/C,KAAI,MAAM,OAAO,IAAI,QAAQ,EAAC,CAAC;QAC7B,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE;YAEpC,KAAI,MAAM,WAAW,IAAI,YAAY,EAAC,CAAC;gBACrC,MAAM,OAAO,GAAG,OAAO,WAAW,KAAK,QAAQ;oBAC7C,CAAC,CAAC,WAAW;oBACb,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC;gBAExB,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBAEzC,IAAG,CAAC,OAAO,EAAC,CAAC;oBACX,SAAS;gBACX,CAAC;gBAED,MAAM,OAAO,GAAG,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,OAAO;oBACrE,CAAC,CAAC,sBAAsB,SAAS,IAAI;oBACrC,CAAC,CAAC,mBAAmB,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAEtD,IAAG,OAAO,WAAW,KAAK,QAAQ,EAAC,CAAC;oBAClC,OAAO;wBACL,OAAO;qBACC,CAAC;gBACb,CAAC;gBAED,IAAG,WAAW,CAAC,GAAG,KAAK,SAAS,EAAC,CAAC;oBAChC,OAAO;wBACL,GAAG,EAAE,mBAAmB,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC;wBAClD,OAAO;qBACC,CAAC;gBACb,CAAC;gBAED,OAAO;oBACL,OAAO;iBACC,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,225 @@
+export declare const noUnknownClasses: {
+    category: "correctness";
+    messages: {
+        readonly unknown: "Unknown class detected: {{ className }}";
+    } | undefined;
+    name: "no-unknown-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;
+        })[];
+    } & {
+        ignore: string[];
+    };
+    recommended: true;
+    rule: {
+        create: (ctx: import("eslint").Rule.RuleContext) => import("eslint").Rule.RuleListener;
+        meta: {
+            messages?: {
+                readonly unknown: "Unknown class detected: {{ 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-unknown-classes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-unknown-classes.d.ts","sourceRoot":"","sources":["../../src/rules/no-unknown-classes.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC3B,CAAC"}

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

@@ -0,0 +1,82 @@
+import { array, description, optional, pipe, strictObject, string } from "valibot";
+import { createGetCustomComponentClasses, getCustomComponentClasses } from "../tailwindcss/custom-component-classes.js";
+import { createGetPrefix, getPrefix } from "../tailwindcss/prefix.js";
+import { createGetUnknownClasses, getUnknownClasses } from "../tailwindcss/unknown-classes.js";
+import { async } from "../utils/context.js";
+import { escapeForRegex } from "../async-utils/escape.js";
+import { lintClasses } from "../utils/lint.js";
+import { getCachedRegex } from "../async-utils/regex.js";
+import { createRule } from "../utils/rule.js";
+import { isConcatenatedLeft, isConcatenatedRight, splitClasses } from "../utils/utils.js";
+export const noUnknownClasses = createRule({
+    autofix: true,
+    category: "correctness",
+    description: "Disallow any css classes that are not registered in tailwindcss.",
+    docs: "https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/rules/no-unknown-classes.md",
+    name: "no-unknown-classes",
+    recommended: true,
+    messages: {
+        unknown: "Unknown class detected: {{ className }}"
+    },
+    schema: strictObject({
+        ignore: optional(pipe(array(string()), description("A list of regular expression patterns for classes that should be ignored by the rule.")), [])
+    }),
+    initialize: ctx => {
+        const { detectComponentClasses } = ctx.options;
+        createGetPrefix(ctx);
+        createGetUnknownClasses(ctx);
+        if (detectComponentClasses) {
+            createGetCustomComponentClasses(ctx);
+        }
+    },
+    lintLiterals: (ctx, literals) => lintLiterals(ctx, literals)
+});
+function lintLiterals(ctx, literals) {
+    const { ignore } = ctx.options;
+    const asyncCtx = async(ctx);
+    const { prefix, suffix } = getPrefix(asyncCtx);
+    const ignoredGroups = getCachedRegex(`^${escapeForRegex(`${prefix}${suffix}`)}group(?:\\/(\\S*))?$`);
+    const ignoredPeers = getCachedRegex(`^${escapeForRegex(`${prefix}${suffix}`)}peer(?:\\/(\\S*))?$`);
+    const customComponentClassRegexes = getCustomComponentClassRegexes(ctx, asyncCtx);
+    for (const literal of literals) {
+        const classes = splitClasses(literal.content);
+        const { unknownClasses, warnings } = getUnknownClasses(asyncCtx, classes);
+        if (unknownClasses.length === 0) {
+            continue;
+        }
+        lintClasses(ctx, literal, (className, classIndex) => {
+            const isFirstClass = classIndex === 0;
+            const isLastClass = classIndex === classes.length - 1;
+            if (isFirstClass && isConcatenatedLeft(literal) ||
+                isLastClass && isConcatenatedRight(literal)) {
+                return;
+            }
+            if (!unknownClasses.includes(className)) {
+                return;
+            }
+            if (ignore.some(ignoredClass => getCachedRegex(ignoredClass).test(className)) ||
+                customComponentClassRegexes?.some(customComponentClassesRegex => customComponentClassesRegex.test(className)) ||
+                ignoredGroups.test(className) ||
+                ignoredPeers.test(className)) {
+                return;
+            }
+            return {
+                data: {
+                    className
+                },
+                id: "unknown",
+                warnings
+            };
+        });
+    }
+}
+function getCustomComponentClassRegexes(ctx, asyncCtx) {
+    const { detectComponentClasses } = ctx.options;
+    if (!detectComponentClasses) {
+        return;
+    }
+    const { customComponentClasses } = getCustomComponentClasses(asyncCtx);
+    const { prefix, suffix } = getPrefix(asyncCtx);
+    return customComponentClasses.map(className => getCachedRegex(`^${escapeForRegex(`${prefix}${suffix}`)}(?:.*:)?${escapeForRegex(className)}$`));
+}
+//# sourceMappingURL=no-unknown-classes.js.map

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

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