@master/eslint-plugin-css 2.0.0-rc.8 → 2.0.0-rc.81

package/dist/rules/prefer-canonical-classes.js

@@ -0,0 +1,95 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import reportLintDiagnostics from "../utils/report-lint-diagnostics.js";
+import defineSourceVisitors, { shouldUseSourceVisitors } from "../utils/define-source-visitors.js";
+import resolveComposeDirectiveClassNodes from "../utils/resolve-compose-directive-class-nodes.js";
+import { createCanonicalClassesReport, createCanonicalComposeDirectiveReport, defaultCanonicalClassNameOptions } from "@master/css-lint";
+//#region src/rules/prefer-canonical-classes.ts
+var prefer_canonical_classes_default = create_rule_default({
+	name: "prefer-canonical-classes",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer canonical Master CSS classes" },
+		messages: { preferClass: "Prefer \"{{recommended}}\" over \"{{actual}}\"." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: {
+				preferStaticUtilities: { type: "boolean" },
+				preferThemeTokens: { type: "boolean" },
+				preferPropertyAliases: { type: "boolean" },
+				preferVariableReferences: { type: "boolean" },
+				preferMultiValueTokens: { type: "boolean" },
+				preferCompositionUtilities: { type: "boolean" },
+				preferConditionOrder: { type: "boolean" },
+				preferNativeDeclarationsInCompose: { type: "boolean" },
+				preferVariantBlocksInCompose: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultCanonicalClassNameOptions],
+	create(context) {
+		const { settings, css } = resolveContext(context);
+		const options = {
+			...defaultCanonicalClassNameOptions,
+			...context.options[0] || {}
+		};
+		if (shouldUseSourceVisitors(context)) return defineSourceVisitors({
+			context,
+			css,
+			ruleId: "prefer-canonical-classes",
+			ruleOptions: options
+		});
+		const reportCanonicalClassList = (node, { raw, start, end, unescape, classNodes, classValues }) => {
+			reportLintDiagnostics(context, node, {
+				raw,
+				start,
+				end,
+				unescape,
+				classNodes,
+				classValues,
+				nodes: [],
+				value: raw
+			}, createCanonicalClassesReport(raw, css, {
+				...options,
+				unescape
+			}).diagnostics);
+		};
+		const reportCanonicalComposeDirective = (node, classNode) => {
+			reportLintDiagnostics(context, node, classNode, createCanonicalComposeDirectiveReport(classNode.raw, css, options).diagnostics, { getFix(_, fix) {
+				if (fix.scope !== "directive") return {
+					range: [classNode.start + fix.range.start, classNode.start + fix.range.end],
+					text: fix.text
+				};
+				return {
+					range: [classNode.directiveStart, classNode.directiveEnd],
+					text: formatComposeDirectiveReplacement(context.sourceCode.getText(), classNode.directiveStart, fix.text)
+				};
+			} });
+		};
+		const visitors = defineVisitors({
+			context,
+			settings
+		}, reportCanonicalClassList);
+		const visitProgram = visitors.Program;
+		return {
+			...visitors,
+			Program(node) {
+				if (typeof visitProgram === "function") visitProgram(node);
+				for (const classNode of resolveComposeDirectiveClassNodes(context)) reportCanonicalComposeDirective(node, classNode);
+			}
+		};
+	}
+});
+function getLinePrefix(source, index) {
+	return source.slice(source.lastIndexOf("\n", index - 1) + 1, index);
+}
+function formatComposeDirectiveReplacement(source, index, replacement) {
+	const linePrefix = getLinePrefix(source, index);
+	if (/\S/.test(linePrefix)) return replacement.replace(/\n\s*/g, " ");
+	return replacement.replace(/\n/g, `\n${linePrefix}`);
+}
+//#endregion
+export { prefer_canonical_classes_default as default };

package/dist/rules/sort-classes.d.ts

@@ -0,0 +1,6 @@
+//#region src/rules/sort-classes.d.ts
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default as default };

package/dist/rules/sort-classes.js

@@ -0,0 +1,44 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import reportLintDiagnostics from "../utils/report-lint-diagnostics.js";
+import defineSourceVisitors, { shouldUseSourceVisitors } from "../utils/define-source-visitors.js";
+import { createSortClassesReport } from "@master/css-lint";
+//#region src/rules/sort-classes.ts
+var sort_classes_default = create_rule_default({
+	name: "sort-classes",
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: { description: "Sort Master CSS classes" },
+		messages: { invalidClassOrder: "No consistent class order followed." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: function(context) {
+		const { settings, css } = resolveContext(context);
+		if (shouldUseSourceVisitors(context)) return defineSourceVisitors({
+			context,
+			css,
+			ruleId: "sort-classes"
+		});
+		return defineVisitors({
+			context,
+			settings
+		}, (node, { raw, start, end, nodes, unescape }) => {
+			if (nodes.length <= 1) return;
+			reportLintDiagnostics(context, node, {
+				raw,
+				start,
+				end,
+				nodes,
+				unescape,
+				value: raw,
+				classNodes: [],
+				classValues: []
+			}, createSortClassesReport(raw, css, { unescape }).diagnostics);
+		});
+	}
+});
+//#endregion
+export { sort_classes_default as default };

package/dist/settings-schema.d.ts

@@ -0,0 +1,7 @@
+import { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+//#region src/settings-schema.d.ts
+declare const masterCSSSettingsSchema: JSONSchema4;
+declare const noInvalidClassesOptionsSchema: JSONSchema4;
+//#endregion
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings-schema.js

@@ -0,0 +1,27 @@
+//#region src/settings-schema.ts
+const sourceMatcherSchema = {
+	type: "array",
+	items: {
+		type: "string",
+		minLength: 1
+	},
+	uniqueItems: true
+};
+const masterCSSSettingsSchema = {
+	type: "object",
+	properties: {
+		classAttributes: sourceMatcherSchema,
+		classFunctions: sourceMatcherSchema,
+		classDeclarations: sourceMatcherSchema,
+		ignoredKeys: sourceMatcherSchema,
+		manifest: { type: "object" }
+	},
+	additionalProperties: false
+};
+const noInvalidClassesOptionsSchema = {
+	type: "object",
+	properties: { disallowUnknownClass: { type: "boolean" } },
+	additionalProperties: false
+};
+//#endregion
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings.d.ts

@@ -1,7 +1,19 @@
+import { MasterCSSManifest } from "./utils/master-css.js";
+
+//#region src/settings.d.ts
 declare const settings: {
-    calleeMatching: string;
-    classMatching: string;
-    ignoredKeys: string[];
-    config: string;
+  manifest: any;
+  classAttributes: string[];
+  classFunctions: string[];
+  classDeclarations: string[];
+  ignoredKeys: string[];
 };
-export default settings;
+interface Settings {
+  classAttributes?: string[];
+  classFunctions?: string[];
+  classDeclarations?: string[];
+  ignoredKeys: string[];
+  manifest?: MasterCSSManifest;
+}
+//#endregion
+export { Settings, settings as default };

package/dist/settings.js

@@ -1 +1,8 @@
-var e=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var o=Object.prototype.hasOwnProperty;var r=(a,s)=>{for(var t in s)e(a,t,{get:s[t],enumerable:!0})},d=(a,s,t,l)=>{if(s&&typeof s=="object"||typeof s=="function")for(let c of i(s))!o.call(a,c)&&c!==t&&e(a,c,{get:()=>s[c],enumerable:!(l=n(s,c))||l.enumerable});return a};var g=a=>d(e({},"__esModule",{value:!0}),a);var u={};r(u,{default:()=>f});module.exports=g(u);const m={calleeMatching:"^(classnames|clsx|ctl|cva|cv|classVariant|styled(?:\\.\\w+)?)",classMatching:"^class(Name)?$",ignoredKeys:["compoundVariants","defaultVariants"],config:"master.css.*"};var f=m;
+import { defaultClassLintSettings } from "@master/css-lint";
+//#region src/settings.ts
+const settings = {
+	...defaultClassLintSettings,
+	manifest: void 0
+};
+//#endregion
+export { settings as default };

package/dist/stylesheet-parser.d.ts

@@ -0,0 +1,31 @@
+//#region src/stylesheet-parser.d.ts
+declare const _default: {
+  meta: {
+    name: string;
+  };
+  parseForESLint(source: string): {
+    ast: {
+      type: string;
+      body: any[];
+      comments: any[];
+      tokens: any[];
+      sourceType: string;
+      range: number[];
+      loc: {
+        start: {
+          line: number;
+          column: number;
+        };
+        end: {
+          line: number;
+          column: number;
+        };
+      };
+    };
+    visitorKeys: {
+      Program: any[];
+    };
+  };
+};
+//#endregion
+export { _default as default };

package/dist/stylesheet-parser.js

@@ -0,0 +1,33 @@
+//#region src/stylesheet-parser.ts
+function getLocFromIndex(source, index) {
+	const lines = source.slice(0, index).split(/\r\n|[\n\r]/);
+	return {
+		line: lines.length,
+		column: lines[lines.length - 1].length
+	};
+}
+var stylesheet_parser_default = {
+	meta: { name: "@master/eslint-plugin-css/stylesheet-parser" },
+	parseForESLint(source) {
+		return {
+			ast: {
+				type: "Program",
+				body: [],
+				comments: [],
+				tokens: [],
+				sourceType: "module",
+				range: [0, source.length],
+				loc: {
+					start: {
+						line: 1,
+						column: 0
+					},
+					end: getLocFromIndex(source, source.length)
+				}
+			},
+			visitorKeys: { Program: [] }
+		};
+	}
+};
+//#endregion
+export { stylesheet_parser_default as default };

package/dist/utils/define-source-visitors.d.ts

@@ -0,0 +1,21 @@
+import { MasterCSSLintContentRuleOptions, MasterCSSLintRuleId } from "@master/css-lint";
+import { MasterCSS } from "@master/css-engine";
+import { RuleContext, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+
+//#region src/utils/define-source-visitors.d.ts
+type SourceRuleOptions = MasterCSSLintContentRuleOptions[keyof MasterCSSLintContentRuleOptions];
+interface DefineSourceVisitorsOptions {
+  context: RuleContext<any, any[]>;
+  css: MasterCSS;
+  ruleId: MasterCSSLintRuleId;
+  ruleOptions?: SourceRuleOptions;
+}
+declare function shouldUseSourceVisitors(context: RuleContext<any, any[]>): boolean;
+declare function defineSourceVisitors({
+  context,
+  css,
+  ruleId,
+  ruleOptions
+}: DefineSourceVisitorsOptions): RuleListener;
+//#endregion
+export { defineSourceVisitors as default, shouldUseSourceVisitors };

package/dist/utils/define-source-visitors.js

@@ -0,0 +1,52 @@
+import { messageIdByCode, stringifyLintDiagnosticData } from "./report-lint-diagnostics.js";
+import { lintMasterCSSContent, masterCSSLintRuleIds } from "@master/css-lint";
+//#region src/utils/define-source-visitors.ts
+const SOURCE_LINT_FILE_RE = /\.mdx$/i;
+function shouldUseSourceVisitors(context) {
+	const filename = context.physicalFilename || context.filename;
+	return typeof filename === "string" && SOURCE_LINT_FILE_RE.test(filename);
+}
+function getFilename(context) {
+	return context.physicalFilename || context.filename || "source.mdx";
+}
+function createSingleRuleSet(ruleId) {
+	return Object.fromEntries(masterCSSLintRuleIds.map((eachRuleId) => [eachRuleId, eachRuleId === ruleId]));
+}
+function createRuleOptions(ruleId, ruleOptions) {
+	return ruleOptions ? { [ruleId]: ruleOptions } : void 0;
+}
+function reportSourceDiagnostic(context, node, diagnostic) {
+	const { sourceCode } = context;
+	const messageId = messageIdByCode[diagnostic.code];
+	const fix = diagnostic.fixes?.[0];
+	const descriptor = {
+		node,
+		loc: {
+			start: sourceCode.getLocFromIndex(diagnostic.range.start),
+			end: sourceCode.getLocFromIndex(diagnostic.range.end)
+		},
+		...messageId ? {
+			messageId,
+			data: stringifyLintDiagnosticData(diagnostic.data || { message: diagnostic.message })
+		} : { message: diagnostic.message }
+	};
+	if (fix) descriptor.fix = (fixer) => fixer.replaceTextRange([fix.range.start, fix.range.end], fix.text);
+	context.report(descriptor);
+}
+function defineSourceVisitors({ context, css, ruleId, ruleOptions }) {
+	return { Program(node) {
+		const result = lintMasterCSSContent({
+			content: context.sourceCode.getText(),
+			filePath: getFilename(context),
+			css,
+			rules: createSingleRuleSet(ruleId),
+			ruleOptions: createRuleOptions(ruleId, ruleOptions)
+		});
+		for (const diagnostic of result.diagnostics) {
+			if (diagnostic.ruleId !== ruleId) continue;
+			reportSourceDiagnostic(context, node, diagnostic);
+		}
+	} };
+}
+//#endregion
+export { defineSourceVisitors as default, shouldUseSourceVisitors };

package/dist/utils/define-visitors.d.ts

@@ -1,5 +1,15 @@
-import { Rule } from 'eslint';
-export default function defineVisitors({ context, settings }: {
-    context: Rule.RuleContext;
-    settings: any;
-}, visitNode: any): any;
+import { TSESTree } from "@typescript-eslint/utils";
+import { Settings } from "../settings.js";
+import { RuleContext, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+import resolveClassNode from "./resolve-class-node.js";
+
+//#region src/utils/define-visitors.d.ts
+declare function defineVisitors({
+  context,
+  settings
+}: {
+  context: RuleContext<any, any[]>;
+  settings: Settings;
+}, visitNode: (node: TSESTree.Node, resolved: ReturnType<typeof resolveClassNode>) => void): RuleListener;
+//#endregion
+export { defineVisitors as default };

package/dist/utils/define-visitors.js

@@ -1 +1,107 @@
-var p=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var E=(s,r)=>{for(var t in r)p(s,t,{get:r[t],enumerable:!0})},v=(s,r,t,l)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of o(r))!x.call(s,i)&&i!==t&&p(s,i,{get:()=>r[i],enumerable:!(l=m(r,i))||l.enumerable});return s};var g=s=>v(p({},"__esModule",{value:!0}),s);var V={};E(V,{default:()=>f});module.exports=g(V);function f({context:s,settings:r},t){const l=e=>{let a="";const n=e.callee||e.tag;return n.type==="Identifier"&&(a=n.name),n.type==="MemberExpression"&&(a=`${n.object.name}.${n.property.name}`),new RegExp(r.calleeMatching).test(a)},i=function(e){l(e)&&e.arguments.forEach(a=>{t(e,a)})},u=new RegExp(r.classMatching),c={CallExpression:i,JSXAttribute:function(e){!e.name||!u.test(e.name.name)||(e.value&&e.value.type==="Literal"?t(e):e.value&&e.value.type==="JSXExpressionContainer"&&t(e,e.value.expression))},SvelteAttribute:function(e){if(!(!e.key?.name||!u.test(e.key.name)))for(const a of e.value)t(e,a)},TextAttribute:function(e){!e.name||!u.test(e.name)||t(e)},TaggedTemplateExpression:function(e){if(l(e)){t(e,e.quasi);return}}},y={CallExpression:i,VAttribute:function(e){e.value&&e.value.type==="VLiteral"?t(e):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ArrayExpression"?e.value.expression.elements.forEach(a=>{t(e,a)}):e.value&&e.value.type==="VExpressionContainer"&&e.value.expression.type==="ObjectExpression"&&e.value.expression.properties.forEach(a=>{t(e,a)})}};return s.sourceCode.parserServices==null||s.sourceCode.parserServices.defineTemplateBodyVisitor==null?c:s.sourceCode.parserServices.defineTemplateBodyVisitor(y,c)}
+import withVisitClassNode from "./with-visit-class-node.js";
+//#region src/utils/define-visitors.ts
+function defineVisitors({ context, settings }, visitNode) {
+	const classAttributeRegex = new RegExp(`^(?:${settings.classAttributes.join("|")})$`);
+	const classFunctionsRegex = new RegExp(`^(?:${settings.classFunctions.join("|")})$`);
+	const classDeclarationsRegex = new RegExp(`^(?:${settings.classDeclarations.join("|")})$`);
+	const visitClassNode = withVisitClassNode(visitNode, context);
+	const getStaticName = (node) => {
+		if (!node) return;
+		if (node.type === "Identifier") return node.name;
+		if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	};
+	const getMemberExpressionName = (node) => {
+		if (!node || node.type !== "MemberExpression") return;
+		const objectName = getStaticName(node.object);
+		const propertyName = getStaticName(node.property);
+		if (!objectName || !propertyName) return;
+		return `${objectName}.${propertyName}`;
+	};
+	const getCalleeName = (node) => {
+		const calleeNode = node.callee || node.tag;
+		return getStaticName(calleeNode) || getMemberExpressionName(calleeNode);
+	};
+	const allowCalleeNode = (node) => {
+		const calleeName = getCalleeName(node);
+		return calleeName ? classFunctionsRegex.test(calleeName) : false;
+	};
+	const getPropertyName = (prop) => getStaticName(prop.key);
+	const visitUtilityDefinitions = (node) => {
+		if (!node) return;
+		if (node.type === "ArrayExpression") {
+			node.elements.forEach((element) => {
+				if (!element || element.type === "ObjectExpression") return;
+				visitClassNode(element);
+			});
+			return;
+		}
+		if (node.type !== "ObjectExpression") {
+			visitClassNode(node);
+			return;
+		}
+	};
+	const visitClassDeclarationNode = (name, node) => {
+		if (name !== "utilities") {
+			visitClassNode(node);
+			return;
+		}
+		visitUtilityDefinitions(node);
+	};
+	const CallExpression = function(node) {
+		if (!allowCalleeNode(node)) return;
+		node.arguments.forEach((node) => {
+			visitClassNode(node);
+		});
+	};
+	const scriptVisitor = {
+		CallExpression,
+		JSXAttribute: function(node) {
+			if (!node.name || !classAttributeRegex.test(node.name.name)) return;
+			if (node.value) visitClassNode(node.value);
+		},
+		SvelteAttribute: function(node) {
+			if (!node.key?.name || !classAttributeRegex.test(node.key.name)) return;
+			for (const eachValue of node.value) visitClassNode(eachValue);
+		},
+		TextAttribute: function(node) {
+			if (!node.name || !classAttributeRegex.test(node.name)) return;
+			visitClassNode(node);
+		},
+		TaggedTemplateExpression: function(node) {
+			if (allowCalleeNode(node)) {
+				visitClassNode(node.quasi);
+				return;
+			}
+		},
+		VariableDeclaration: function(node) {
+			node.declarations.forEach((decl) => {
+				if (decl.id.type === "Identifier" && classDeclarationsRegex.test(decl.id.name)) visitClassDeclarationNode(decl.id.name, decl.init);
+			});
+		},
+		ObjectExpression: function(node) {
+			node.properties.forEach((prop) => {
+				if (prop.type === "Property") {
+					const propName = getPropertyName(prop);
+					if (typeof propName === "string" && classDeclarationsRegex.test(propName)) visitClassDeclarationNode(propName, prop.value);
+				}
+			});
+		}
+	};
+	const templateBodyVisitor = {
+		CallExpression,
+		VAttribute: function(node) {
+			const name = node.key?.argument?.name || node.key?.name;
+			if (!name || !classAttributeRegex.test(name)) return;
+			if (node.value && node.value.type === "VLiteral") visitClassNode(node.value);
+			else if (node.value) {
+				if (node.value.type === "VExpressionContainer") {
+					if (node.value.expression?.type === "ArrayExpression" || node.value.expression?.type === "ObjectExpression") visitClassNode(node.value.expression);
+				}
+			}
+		}
+	};
+	if (context.sourceCode.parserServices == null || context.sourceCode.parserServices.defineTemplateBodyVisitor == null) return scriptVisitor;
+	else return context.sourceCode.parserServices.defineTemplateBodyVisitor(templateBodyVisitor, scriptVisitor);
+}
+//#endregion
+export { defineVisitors as default };

package/dist/utils/is-same-or-child-path.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/is-same-or-child-path.d.ts
+declare function isSameOrChildPath(parentPath: string, childPath: string): boolean;
+//#endregion
+export { isSameOrChildPath as default };

package/dist/utils/is-same-or-child-path.js

@@ -0,0 +1,8 @@
+import path from "node:path";
+//#region src/utils/is-same-or-child-path.ts
+function isSameOrChildPath(parentPath, childPath) {
+	const relativePath = path.relative(parentPath, childPath);
+	return relativePath === "" || !!relativePath && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+//#endregion
+export { isSameOrChildPath as default };

package/dist/utils/master-css.d.ts

@@ -0,0 +1,7 @@
+import { createCSSWithNativeDeclarations } from "@master/css-validator";
+import { MasterCSS, MasterCSSManifest } from "@master/css";
+
+//#region src/utils/master-css.d.ts
+declare const defaultManifest: MasterCSSManifest;
+//#endregion
+export { type MasterCSS, type MasterCSSManifest, createCSSWithNativeDeclarations, defaultManifest };

package/dist/utils/master-css.js

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+import { createCSSWithNativeDeclarations } from "@master/css-validator";
+//#region src/utils/master-css.ts
+const defaultManifest = createRequire(import.meta.url)("@master/css-preset/default-manifest.json");
+//#endregion
+export { createCSSWithNativeDeclarations, defaultManifest };

package/dist/utils/report-lint-diagnostics.d.ts

@@ -0,0 +1,20 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { MasterCSSLintDiagnostic, MasterCSSLintFix } from "@master/css-lint";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import { ResolvedClassNode } from "./resolve-class-node.js";
+
+//#region src/utils/report-lint-diagnostics.d.ts
+type FixRange = [number, number];
+interface ReportLintDiagnosticsOptions {
+  getFix?: (diagnostic: MasterCSSLintDiagnostic, fix: MasterCSSLintFix) => {
+    range: FixRange;
+    text: string;
+  } | undefined;
+}
+declare const messageIdByCode: Record<string, string>;
+declare function stringifyLintDiagnosticData(data?: MasterCSSLintDiagnostic['data']): {
+  [k: string]: string;
+};
+declare function reportLintDiagnostics(context: RuleContext<any, any[]>, node: TSESTree.Node, resolved: ResolvedClassNode, diagnostics: MasterCSSLintDiagnostic[], options?: ReportLintDiagnosticsOptions): void;
+//#endregion
+export { reportLintDiagnostics as default, messageIdByCode, stringifyLintDiagnosticData };

package/dist/utils/report-lint-diagnostics.js

@@ -0,0 +1,46 @@
+//#region src/utils/report-lint-diagnostics.ts
+const messageIdByCode = {
+	"invalid-class-order": "invalidClassOrder",
+	"invalid-class": "invalidClass",
+	"unknown-class": "disallowUnknownClass",
+	"conflicting-class": "collisionClass",
+	"partially-conflicting-class": "partialCollisionClass",
+	"prefer-canonical-class": "preferClass",
+	"prefer-native-declaration": "preferClass",
+	"prefer-variant-block": "preferClass",
+	"unapproved-raw-value": "unapprovedRawValue"
+};
+function stringifyLintDiagnosticData(data = {}) {
+	return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== void 0).map(([key, value]) => [key, Array.isArray(value) ? value.join(", ") : String(value)]));
+}
+function defaultFix(resolved, fix) {
+	if (fix.scope === "directive") return;
+	return {
+		range: [resolved.start + fix.range.start, resolved.start + fix.range.end],
+		text: fix.text
+	};
+}
+function reportLintDiagnostics(context, node, resolved, diagnostics, options = {}) {
+	const { sourceCode } = context;
+	for (const diagnostic of diagnostics) {
+		const start = resolved.start + diagnostic.range.start;
+		const end = resolved.start + diagnostic.range.end;
+		const messageId = messageIdByCode[diagnostic.code];
+		const fix = diagnostic.fix ? options.getFix?.(diagnostic, diagnostic.fix) || defaultFix(resolved, diagnostic.fix) : void 0;
+		const descriptor = {
+			node,
+			loc: {
+				start: sourceCode.getLocFromIndex(start),
+				end: sourceCode.getLocFromIndex(end)
+			},
+			...messageId ? {
+				messageId,
+				data: stringifyLintDiagnosticData(diagnostic.data || { message: diagnostic.message })
+			} : { message: diagnostic.message }
+		};
+		if (fix) descriptor.fix = (fixer) => fixer.replaceTextRange(fix.range, fix.text);
+		context.report(descriptor);
+	}
+}
+//#endregion
+export { reportLintDiagnostics as default, messageIdByCode, stringifyLintDiagnosticData };

package/dist/utils/resolve-class-node.d.ts

@@ -0,0 +1,24 @@
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+
+//#region src/utils/resolve-class-node.d.ts
+type ResolvedClassListUnescape = string | false;
+interface ResolvedClassListNode {
+  type: 'class' | 'space';
+  value: string;
+  raw: string;
+  range: [number, number];
+  loc: any;
+}
+interface ResolvedClassNode {
+  nodes: ResolvedClassListNode[];
+  start: number;
+  end: number;
+  raw: string;
+  value: string;
+  unescape: ResolvedClassListUnescape;
+  classNodes: ResolvedClassListNode[];
+  classValues: string[];
+}
+declare function resolveClassNode(node: any, context: RuleContext<any, any[]>): ResolvedClassNode | undefined;
+//#endregion
+export { ResolvedClassListNode, ResolvedClassListUnescape, ResolvedClassNode, resolveClassNode as default };