eslint-plugin-better-tailwindcss 4.1.1 → 4.3.0

package/lib/options/callees/twMerge.js

@@ -1,12 +1,13 @@
-import { MatcherType } from "../../types/rule.js";
-export const TW_MERGE_STRINGS = [
-    "twMerge",
-    [
+import { MatcherType, SelectorKind } from "../../types/rule.js";
+export const TW_MERGE_STRINGS = {
+    kind: SelectorKind.Callee,
+    match: [
         {
-            match: MatcherType.String
+            type: MatcherType.String
         }
-    ]
-];
+    ],
+    name: "twMerge"
+};
 /** @see https://github.com/dcastil/tailwind-merge */
 export const TW_MERGE = [
     TW_MERGE_STRINGS

package/lib/options/callees/twMerge.js.map

@@ -1 +1 @@
-{"version":3,"file":"twMerge.js","sourceRoot":"","sources":["../../../src/options/callees/twMerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAK/D,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,SAAS;IACT;QACE;YACE,KAAK,EAAE,WAAW,CAAC,MAAM;SAC1B;KACF;CACuB,CAAC;AAE3B,qDAAqD;AACrD,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,gBAAgB;CACC,CAAC"}
+{"version":3,"file":"twMerge.js","sourceRoot":"","sources":["../../../src/options/callees/twMerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAK7E,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,YAAY,CAAC,MAAM;IACzB,KAAK,EAAE;QACL;YACE,IAAI,EAAE,WAAW,CAAC,MAAM;SACzB;KACF;IACD,IAAI,EAAE,SAAS;CACS,CAAC;AAE3B,qDAAqD;AACrD,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,gBAAgB;CACG,CAAC"}

package/lib/options/default-options.d.ts

@@ -1,19 +1,84 @@
-import { MatcherType } from "../types/rule.js";
-export declare const DEFAULT_CALLEE_NAMES: ([string, {
-    match: MatcherType.String;
-}[]] | [string, {
-    match: MatcherType.ObjectKey;
-}[]] | [string, {
-    match: MatcherType.ObjectValue;
-    pathPattern: string;
-}[]])[];
-export declare const DEFAULT_ATTRIBUTE_NAMES: (string | [string, ({
-    match: MatcherType.String;
+import { MatcherType, SelectorKind } from "../types/rule.js";
+export declare const DEFAULT_CALLEE_SELECTORS: ({
+    kind: SelectorKind.Callee;
+    match: {
+        type: MatcherType.String;
+    }[];
+    name: string;
+} | {
+    kind: SelectorKind.Callee;
+    match: {
+        type: MatcherType.ObjectKey;
+    }[];
+    name: string;
 } | {
-    match: MatcherType.ObjectKey;
-})[]])[];
+    kind: SelectorKind.Callee;
+    match: {
+        path: string;
+        type: MatcherType.ObjectValue;
+    }[];
+    name: string;
+})[];
+export declare const DEFAULT_ATTRIBUTE_SELECTORS: ({
+    kind: SelectorKind.Attribute;
+    name: string;
+    match?: never;
+} | {
+    kind: SelectorKind.Attribute;
+    match: ({
+        type: MatcherType.String;
+    } | {
+        type: MatcherType.ObjectKey;
+    })[];
+    name: string;
+})[];
 export declare const DEFAULT_VARIABLE_NAMES: [string, {
     match: MatcherType.String;
 }[]][];
+export declare const DEFAULT_VARIABLE_SELECTORS: {
+    kind: SelectorKind.Variable;
+    match: {
+        type: MatcherType.String;
+    }[];
+    name: string;
+}[];
 export declare const DEFAULT_TAG_NAMES: never[];
+export declare const DEFAULT_SELECTORS: ({
+    kind: SelectorKind.Callee;
+    match: {
+        type: MatcherType.String;
+    }[];
+    name: string;
+} | {
+    kind: SelectorKind.Callee;
+    match: {
+        type: MatcherType.ObjectKey;
+    }[];
+    name: string;
+} | {
+    kind: SelectorKind.Callee;
+    match: {
+        path: string;
+        type: MatcherType.ObjectValue;
+    }[];
+    name: string;
+} | {
+    kind: SelectorKind.Attribute;
+    name: string;
+    match?: never;
+} | {
+    kind: SelectorKind.Attribute;
+    match: ({
+        type: MatcherType.String;
+    } | {
+        type: MatcherType.ObjectKey;
+    })[];
+    name: string;
+} | {
+    kind: SelectorKind.Variable;
+    match: {
+        type: MatcherType.String;
+    }[];
+    name: string;
+})[];
 //# sourceMappingURL=default-options.d.ts.map

package/lib/options/default-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default-options.d.ts","sourceRoot":"","sources":["../../src/options/default-options.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAQ/D,eAAO,MAAM,oBAAoB;;;;;;;OAcd,CAAC;AAEpB,eAAO,MAAM,uBAAuB;;;;QAyEd,CAAC;AAEvB,eAAO,MAAM,sBAAsB;;MAsBd,CAAC;AAEtB,eAAO,MAAM,iBAAiB,SAAoB,CAAC"}
+{"version":3,"file":"default-options.d.ts","sourceRoot":"","sources":["../../src/options/default-options.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAO7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;IAchB,CAAC;AAEtB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;IAiFnB,CAAC;AAEtB,eAAO,MAAM,sBAAsB;;MAsBd,CAAC;AAEtB,eAAO,MAAM,0BAA0B;;;;;;GA4BlB,CAAC;AAEtB,eAAO,MAAM,iBAAiB,SAAoB,CAAC;AAEnD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIT,CAAC"}

package/lib/options/default-options.js

@@ -11,8 +11,8 @@ import { OBJSTR } from "./callees/objstr.js";
 import { TV } from "./callees/tv.js";
 import { TW_JOIN } from "./callees/twJoin.js";
 import { TW_MERGE } from "./callees/twMerge.js";
-import { MatcherType } from "../types/rule.js";
-export const DEFAULT_CALLEE_NAMES = [
+import { MatcherType, SelectorKind } from "../types/rule.js";
+export const DEFAULT_CALLEE_SELECTORS = [
     ...CC,
     ...CLB,
     ...CLSX,
@@ -27,74 +27,87 @@ export const DEFAULT_CALLEE_NAMES = [
     ...TW_JOIN,
     ...TW_MERGE
 ];
-export const DEFAULT_ATTRIBUTE_NAMES = [
-    // general
-    "^class(?:Name)?$",
-    [
-        "^class(?:Name)?$", [
+export const DEFAULT_ATTRIBUTE_SELECTORS = [
+    {
+        kind: SelectorKind.Attribute,
+        name: "^class(?:Name)?$"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             }
-        ]
-    ],
-    // svelte
-    [
-        "^class:.*", [
+        ],
+        name: "^class(?:Name)?$"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             }
-        ]
-    ],
-    // angular
-    "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)",
-    [
-        "(?:^\\[class\\..*\\]$)", [
+        ],
+        name: "^class:.*"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        name: "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             }
-        ]
-    ],
-    [
-        "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)", [
+        ],
+        name: "(?:^\\[class\\..*\\]$)"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             },
             {
-                match: MatcherType.ObjectKey
+                type: MatcherType.ObjectKey
             }
-        ]
-    ],
-    // vue
-    [
-        "^v-bind:class$", [
+        ],
+        name: "(?:^\\[class\\]$)|(?:^\\[ngClass\\]$)"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             },
             {
-                match: MatcherType.ObjectKey
+                type: MatcherType.ObjectKey
             }
-        ]
-    ],
-    // astro
-    [
-        "^class:list$", [
+        ],
+        name: "^v-bind:class$"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.String
+                type: MatcherType.String
             },
             {
-                match: MatcherType.ObjectKey
+                type: MatcherType.ObjectKey
             }
-        ]
-    ],
-    // solid
-    [
-        "^classList$",
-        [
+        ],
+        name: "^class:list$"
+    },
+    {
+        kind: SelectorKind.Attribute,
+        match: [
             {
-                match: MatcherType.ObjectKey
+                type: MatcherType.ObjectKey
             }
-        ]
-    ]
+        ],
+        name: "^classList$"
+    }
 ];
 export const DEFAULT_VARIABLE_NAMES = [
     [
@@ -119,5 +132,39 @@ export const DEFAULT_VARIABLE_NAMES = [
         ]
     ]
 ];
+export const DEFAULT_VARIABLE_SELECTORS = [
+    {
+        kind: SelectorKind.Variable,
+        match: [
+            {
+                type: MatcherType.String
+            }
+        ],
+        name: "^classNames?$"
+    },
+    {
+        kind: SelectorKind.Variable,
+        match: [
+            {
+                type: MatcherType.String
+            }
+        ],
+        name: "^classes$"
+    },
+    {
+        kind: SelectorKind.Variable,
+        match: [
+            {
+                type: MatcherType.String
+            }
+        ],
+        name: "^styles?$"
+    }
+];
 export const DEFAULT_TAG_NAMES = [];
+export const DEFAULT_SELECTORS = [
+    ...DEFAULT_ATTRIBUTE_SELECTORS,
+    ...DEFAULT_CALLEE_SELECTORS,
+    ...DEFAULT_VARIABLE_SELECTORS
+];
 //# sourceMappingURL=default-options.js.map

package/lib/options/default-options.js.map

@@ -1 +1 @@
-{"version":3,"file":"default-options.js","sourceRoot":"","sources":["../../src/options/default-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0CAA0C,CAAC;AAC9D,OAAO,EAAE,GAAG,EAAE,MAAM,2CAA2C,CAAC;AAChE,OAAO,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AAClE,OAAO,EAAE,EAAE,EAAE,MAAM,0CAA0C,CAAC;AAC9D,OAAO,EAAE,GAAG,EAAE,MAAM,2CAA2C,CAAC;AAChE,OAAO,EAAE,GAAG,EAAE,MAAM,2CAA2C,CAAC;AAChE,OAAO,EAAE,GAAG,EAAE,MAAM,2CAA2C,CAAC;AAChE,OAAO,EAAE,EAAE,EAAE,MAAM,0CAA0C,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,8CAA8C,CAAC;AACtE,OAAO,EAAE,EAAE,EAAE,MAAM,0CAA0C,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,8CAA8C,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,+CAA+C,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAQ/D,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,GAAG,EAAE;IACL,GAAG,GAAG;IACN,GAAG,IAAI;IACP,GAAG,EAAE;IACL,GAAG,GAAG;IACN,GAAG,GAAG;IACN,GAAG,GAAG;IACN,GAAG,EAAE;IACL,GAAG,IAAI;IACP,GAAG,MAAM;IACT,GAAG,EAAE;IACL,GAAG,OAAO;IACV,GAAG,QAAQ;CACM,CAAC;AAEpB,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,UAAU;IACV,kBAAkB;IAClB;QACE,kBAAkB,EAAE;YAClB;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;IAED,SAAS;IACT;QACE,WAAW,EAAE;YACX;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;IAED,UAAU;IACV,uCAAuC;IACvC;QACE,wBAAwB,EAAE;YACxB;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;IACD;QACE,uCAAuC,EAAE;YACvC;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,WAAW,CAAC,SAAS;aAC7B;SACF;KACF;IAED,MAAM;IACN;QACE,gBAAgB,EAAE;YAChB;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,WAAW,CAAC,SAAS;aAC7B;SACF;KACF;IAED,QAAQ;IACR;QACE,cAAc,EAAE;YACd;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;YACD;gBACE,KAAK,EAAE,WAAW,CAAC,SAAS;aAC7B;SACF;KACF;IAED,QAAQ;IACR;QACE,aAAa;QACb;YACE;gBACE,KAAK,EAAE,WAAW,CAAC,SAAS;aAC7B;SACF;KACF;CACmB,CAAC;AAEvB,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC;QACE,eAAe,EAAE;YACf;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;IACD;QACE,WAAW,EAAE;YACX;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;IACD;QACE,WAAW,EAAE;YACX;gBACE,KAAK,EAAE,WAAW,CAAC,MAAM;aAC1B;SACF;KACF;CACkB,CAAC;AAEtB,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAiB,CAAC"}
+{"version":3,"file":"default-options.js","sourceRoot":"","sources":["../../src/options/default-options.ts"],"names":[],"mappings":"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"}

package/lib/options/descriptions.d.ts

@@ -38,7 +38,7 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
     } | {
         match: import("../types/rule.js").MatcherType.ObjectValue;
         pathPattern?: string | undefined;
-    })[]])[], "List of template literal tags that should get linted.">]>, never[]>;
+    })[]])[], "List of template literal tags that should get linted.">]>, undefined>;
     readonly variables: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Variable name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
         readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
     }, undefined>, import("valibot").StrictObjectSchema<{
@@ -71,9 +71,7 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
     } | {
         match: import("../types/rule.js").MatcherType.ObjectValue;
         pathPattern?: string | undefined;
-    })[]])[], "List of variable names which values should get linted.">]>, [string, {
-        match: import("../types/rule.js").MatcherType.String;
-    }[]][]>;
+    })[]])[], "List of variable names which values should get linted.">]>, undefined>;
     readonly attributes: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name that for which children get linted.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Attribute name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
         readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
     }, undefined>, import("valibot").StrictObjectSchema<{
@@ -106,11 +104,7 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
     } | {
         match: import("../types/rule.js").MatcherType.ObjectValue;
         pathPattern?: string | undefined;
-    })[]])[], "List of attribute names that should get linted.">]>, (string | [string, ({
-        match: import("../types/rule.js").MatcherType.String;
-    } | {
-        match: import("../types/rule.js").MatcherType.ObjectKey;
-    })[]])[]>;
+    })[]])[], "List of attribute names that should get linted.">]>, undefined>;
     readonly callees: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").TupleSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Callee name for which children get linted if matched.">]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
         readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
     }, undefined>, import("valibot").StrictObjectSchema<{
@@ -143,14 +137,213 @@ export declare const COMMON_OPTIONS: import("valibot").StrictObjectSchema<{
     } | {
         match: import("../types/rule.js").MatcherType.ObjectValue;
         pathPattern?: string | undefined;
-    })[]])[], "List of function names which arguments should get linted.">]>, ([string, {
-        match: import("../types/rule.js").MatcherType.String;
-    }[]] | [string, {
-        match: import("../types/rule.js").MatcherType.ObjectKey;
-    }[]] | [string, {
-        match: import("../types/rule.js").MatcherType.ObjectValue;
-        pathPattern: string;
-    }[]])[]>;
+    })[]])[], "List of function names which arguments should get linted.">]>, undefined>;
+    readonly selectors: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Attribute, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Attribute, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            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;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            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;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+        readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly callTarget: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"all", undefined>, import("valibot").LiteralSchema<"first", undefined>, import("valibot").LiteralSchema<"last", undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, import("valibot").DescriptionAction<number | "all" | "first" | "last" | undefined, "Optional call target for curried callees: index, first, last, or all.">]>;
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Callee, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Callee, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            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;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>, undefined>;
+        readonly path: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for callee paths that should be linted.">]>;
+    }, undefined>], undefined>, import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Tag, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Tag, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            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;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly kind: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").SelectorKind.Variable, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").SelectorKind.Variable, "Selector kind that determines where matching is applied.">]>;
+        readonly match: import("valibot").SchemaWithPipe<readonly [import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.String, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.String, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object key and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectKey, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectKey, "Matcher type that will be applied.">]>;
+        }, undefined>, import("valibot").StrictObjectSchema<{
+            readonly path: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression that filters the object value and matches the content for further processing in a group.">]>, undefined>;
+            readonly type: import("valibot").SchemaWithPipe<readonly [import("valibot").LiteralSchema<import("../types/rule.js").MatcherType.ObjectValue, undefined>, import("valibot").DescriptionAction<import("../types/rule.js").MatcherType.ObjectValue, "Matcher type that will be applied.">]>;
+        }, undefined>], undefined>, undefined>, undefined>, import("valibot").DescriptionAction<({
+            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;
+        })[] | undefined, "Optional list of matchers that will be applied.">]>;
+        readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").DescriptionAction<string, "Regular expression for names that should be linted.">]>;
+    }, undefined>], undefined>, undefined>, import("valibot").DescriptionAction<({
+        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;
+        })[] | undefined;
+        name: string;
+        path?: string | 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;
+        })[] | 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;
+        })[] | undefined;
+        name: string;
+    } | {
+        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;
+        })[] | 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;
+        })[] | undefined;
+        name: string;
+    })[], "Flat list of selectors that should get linted.">]>, ({
+        kind: import("../types/rule.js").SelectorKind.Callee;
+        match: {
+            type: import("../types/rule.js").MatcherType.String;
+        }[];
+        name: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Callee;
+        match: {
+            type: import("../types/rule.js").MatcherType.ObjectKey;
+        }[];
+        name: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Callee;
+        match: {
+            path: string;
+            type: import("../types/rule.js").MatcherType.ObjectValue;
+        }[];
+        name: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Attribute;
+        name: string;
+        match?: never;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Attribute;
+        match: ({
+            type: import("../types/rule.js").MatcherType.String;
+        } | {
+            type: import("../types/rule.js").MatcherType.ObjectKey;
+        })[];
+        name: string;
+    } | {
+        kind: import("../types/rule.js").SelectorKind.Variable;
+        match: {
+            type: import("../types/rule.js").MatcherType.String;
+        }[];
+        name: string;
+    })[]>;
 }, undefined>;
 export type CommonOptions = InferOutput<typeof COMMON_OPTIONS>;
 //# sourceMappingURL=descriptions.d.ts.map

package/lib/options/descriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAWzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAYzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/lib/options/descriptions.js

@@ -2,9 +2,11 @@ import { strictObject } from "valibot";
 import { ATTRIBUTES_OPTION_SCHEMA } from "./schemas/attributes.js";
 import { CALLEES_OPTION_SCHEMA } from "./schemas/callees.js";
 import { DETECT_COMPONENT_CLASSES_OPTION_SCHEMA, ENTRYPOINT_OPTION_SCHEMA, MESSAGE_STYLE_OPTION_SCHEMA, ROOT_FONT_SIZE_OPTION_SCHEMA, TAILWIND_OPTION_SCHEMA, TSCONFIG_OPTION_SCHEMA } from "./schemas/common.js";
+import { SELECTORS_OPTION_SCHEMA } from "./schemas/selectors.js";
 import { TAGS_OPTIONS_SCHEMA } from "./schemas/tags.js";
 import { VARIABLES_OPTION_SCHEMA } from "./schemas/variables.js";
 export const COMMON_OPTIONS = strictObject({
+    ...SELECTORS_OPTION_SCHEMA.entries,
     ...CALLEES_OPTION_SCHEMA.entries,
     ...ATTRIBUTES_OPTION_SCHEMA.entries,
     ...VARIABLES_OPTION_SCHEMA.entries,

package/lib/options/descriptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAK1F,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,GAAG,qBAAqB,CAAC,OAAO;IAChC,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,mBAAmB,CAAC,OAAO;IAC9B,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,2BAA2B,CAAC,OAAO;IACtC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sCAAsC,CAAC,OAAO;IACjD,GAAG,4BAA4B,CAAC,OAAO;CACxC,CAAC,CAAC"}
+{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../../src/options/descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAC;AAK1F,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAC;IACzC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,qBAAqB,CAAC,OAAO;IAChC,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,uBAAuB,CAAC,OAAO;IAClC,GAAG,mBAAmB,CAAC,OAAO;IAC9B,GAAG,wBAAwB,CAAC,OAAO;IACnC,GAAG,2BAA2B,CAAC,OAAO;IACtC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sBAAsB,CAAC,OAAO;IACjC,GAAG,sCAAsC,CAAC,OAAO;IACjD,GAAG,4BAA4B,CAAC,OAAO;CACxC,CAAC,CAAC"}