@master/eslint-plugin-css 0.0.0-site.1793659883.g69c9aebcf628

package/dist/utils/resolve-class-node.js

@@ -0,0 +1,106 @@
+import { encodeJavaScriptLiteral, javascriptLiteralRange } from "./javascript-literal.js";
+import { resolveVueLiteral } from "./vue-literal.js";
+// src/utils/resolve-class-node.ts
+function resolveClassNode(node, context, lintSession) {
+	const { sourceCode } = context;
+	let value = null;
+	let raw = null;
+	let start = null;
+	let end = null;
+	let unescape = false;
+	const javascript = node.type === "TemplateElement" || node.type === "Literal" && node.parent?.type !== "JSXAttribute";
+	const html = javascript ? resolveVueLiteral(node, sourceCode, lintSession) : void 0;
+	switch (node.type) {
+		case "Literal":
+			value = node.value;
+			raw = html?.raw ?? node.raw;
+			start = node.range[0];
+			end = node.range[1];
+			break;
+		case "VLiteral":
+			value = node.value;
+			raw = sourceCode.getText(node);
+			start = node.range[0];
+			end = node.range[1];
+			break;
+		case "TextAttribute":
+			value = node.value;
+			start = node.valueSpan.fullStart.offset;
+			end = node.valueSpan.end.offset;
+			raw = sourceCode.getText({
+				...node,
+				range: [start, end]
+			});
+			break;
+		case "SvelteLiteral":
+			value = node.value;
+			raw = sourceCode.getText(node);
+			start = node.range[0];
+			end = node.range[1];
+			break;
+		case "TemplateElement":
+			if (node.parent.expressions.length) return;
+			value = node.value.cooked;
+			start = node.range[0];
+			end = node.range[1];
+			raw = html?.raw ?? sourceCode.text.slice(start, end);
+			unescape = "`";
+			break;
+		default: return;
+	}
+	if (typeof value !== "string") return;
+	const rawMatchesSource = raw === sourceCode.text.slice(start, end);
+	let delimiterOffset = 0;
+	if (/^(['"`])([\s\S]*)\1$/.test(raw)) {
+		unescape = raw[0];
+		const contentRange = html?.sourceRange(1, raw.length - 1);
+		raw = raw.slice(1, -1);
+		delimiterOffset = 1;
+		start = contentRange?.[0] ?? start + 1;
+		end = contentRange?.[1] ?? end - 1;
+	}
+	const literalRange = javascript ? javascriptLiteralRange(raw, value) : void 0;
+	const sourceRange = literalRange && ((a, b) => {
+		const [first, last] = literalRange(a, b);
+		if (!html) return [first, last];
+		const [sourceStart, sourceEnd] = html.sourceRange(delimiterOffset + first, delimiterOffset + last);
+		return [sourceStart - start, sourceEnd - start];
+	});
+	if (javascript && !sourceRange) return;
+	const analysisText = javascript ? value : raw;
+	const nodes = lintSession.tokenizeClassList(analysisText, javascript ? false : unescape).map((item) => {
+		const [mappedStart, mappedEnd] = sourceRange?.(item.range.start, item.range.end) ?? [item.range.start, item.range.end];
+		const startOffset = start + mappedStart;
+		const endOffset = start + mappedEnd;
+		return {
+			type: "class",
+			value: item.token,
+			raw: sourceCode.text.slice(startOffset, endOffset),
+			range: [startOffset, endOffset],
+			loc: {
+				start: sourceCode.getLocFromIndex(startOffset),
+				end: sourceCode.getLocFromIndex(endOffset)
+			}
+		};
+	});
+	const classNodes = nodes.filter((node) => node.type === "class");
+	return {
+		nodes,
+		start,
+		end,
+		raw: sourceCode.text.slice(start, end),
+		value,
+		unescape,
+		classNodes,
+		classValues: classNodes.map((node) => node.value),
+		analysisText,
+		sourceRange,
+		encodeReplacement: javascript ? (text) => {
+			const newline = raw.match(/\r\n|\r|\n/)?.[0] ?? "\n";
+			const replacement = encodeJavaScriptLiteral(text, unescape || "\"", newline);
+			return html?.encode(replacement) ?? replacement;
+		} : void 0,
+		canFix: !javascript || Boolean(html) || rawMatchesSource
+	};
+}
+export { resolveClassNode as default };

package/dist/utils/resolve-context.d.ts

@@ -0,0 +1,15 @@
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+declare function resolveContext(context: RuleContext<any, any[]>): {
+  settings: {
+    classAttributes: readonly string[];
+    classFunctions: readonly string[];
+    classDeclarations: readonly string[];
+    ignoredKeys: readonly string[];
+    manifest: any;
+  };
+  options: any;
+  tooling: MasterCSSToolingSession;
+  release(): void;
+};
+export { resolveContext as default };

package/dist/utils/resolve-context.js

@@ -0,0 +1,177 @@
+import settings from "../settings.js";
+import { defaultManifest } from "./master-css.js";
+import isSameOrChildPath from "./is-same-or-child-path.js";
+import { isDependencyCurrent, stampDependency } from "./dependency-stamp.js";
+import { acquireWorkspaceSnapshot, releaseWorkspaceSnapshot } from "./workspace-cache.js";
+import { createSourceTooling } from "./source-tooling.js";
+import { loadProjectManifestSync } from "@master/css-compiler/project/sync";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { createToolingSessionSync } from "@master/css-tooling/node";
+// src/utils/resolve-context.ts
+const sourceCaches = /* @__PURE__ */ new WeakMap();
+const cssCaches = [];
+const CACHE_IDLE_DISPOSE_DELAY = 1e3;
+function disposeCSSCache(cache) {
+	if (cache.disposeTimer) clearTimeout(cache.disposeTimer);
+	cache.disposeTimer = void 0;
+	cache.tooling.dispose();
+	const index = cssCaches.indexOf(cache);
+	if (index !== -1) cssCaches.splice(index, 1);
+}
+function scheduleCSSCacheDisposal(cache) {
+	if (cache.references || cache.disposeTimer) return;
+	cache.disposeTimer = setTimeout(() => {
+		cache.disposeTimer = void 0;
+		if (!cache.references) disposeCSSCache(cache);
+	}, CACHE_IDLE_DISPOSE_DELAY);
+	cache.disposeTimer.unref?.();
+}
+function retainCSSCache(cache) {
+	if (cache.disposeTimer) clearTimeout(cache.disposeTimer);
+	cache.disposeTimer = void 0;
+	cache.references++;
+}
+function getContextFilename(context) {
+	const filename = context.physicalFilename || context.filename;
+	if (!filename || filename.startsWith("<")) return;
+	return path.isAbsolute(filename) ? filename : path.resolve(context.cwd, filename);
+}
+function getWorkspaceSnapshot(sourceCache, cwd) {
+	let snapshot = sourceCache.workspaces.get(cwd);
+	if (!snapshot) {
+		snapshot = acquireWorkspaceSnapshot(cwd);
+		sourceCache.workspaces.set(cwd, snapshot);
+	}
+	return snapshot;
+}
+function findNearestPackageDirectory(filename) {
+	let directory = path.dirname(filename);
+	const root = path.parse(directory).root;
+	while (directory !== root) {
+		if (existsSync(path.join(directory, "package.json"))) return directory;
+		directory = path.dirname(directory);
+	}
+	return path.dirname(filename);
+}
+function resolveSearchDirectory(context, filename) {
+	const cwd = path.resolve(context.cwd || process.cwd());
+	if (cwd !== path.parse(cwd).root && isSameOrChildPath(cwd, filename)) return cwd;
+	return findNearestPackageDirectory(filename);
+}
+function resolveWorkspaceDirectory(context, sourceCache, filename) {
+	const cwd = resolveSearchDirectory(context, filename);
+	const discovery = getWorkspaceSnapshot(sourceCache, cwd);
+	let closestDirectory;
+	for (const directory of discovery.directories) if (isSameOrChildPath(directory, filename) && (!closestDirectory || directory.length > closestDirectory.length)) closestDirectory = directory;
+	return {
+		workspaceDir: closestDirectory || cwd,
+		discovery
+	};
+}
+function resolvePlan(workspaceDir, manifest) {
+	const result = loadProjectManifestSync({
+		root: workspaceDir,
+		baseManifest: manifest ?? defaultManifest
+	});
+	return {
+		manifest: result.entries.length ? result.manifest : manifest,
+		dependencies: result.dependencies
+	};
+}
+function resolveTooling(context, sourceCache, resolvedSettings) {
+	const filename = getContextFilename(context);
+	const { workspaceDir, discovery } = filename ? resolveWorkspaceDirectory(context, sourceCache, filename) : {
+		workspaceDir: context.cwd || process.cwd(),
+		discovery: void 0
+	};
+	const configuredManifestSignature = resolvedSettings.manifest ? JSON.stringify(resolvedSettings.manifest) : void 0;
+	let cache = sourceCache.cssCaches.find((cache) => cache.manifest === resolvedSettings.manifest && cache.cwd === workspaceDir);
+	if (!cache) {
+		cache = cssCaches.find((cache) => cache.manifest === resolvedSettings.manifest && cache.cwd === workspaceDir);
+		if (cache && (cache.configuredManifestSignature !== configuredManifestSignature || cache.discovery !== discovery || !cache.dependencies.every(isDependencyCurrent))) {
+			if (cache.references) {
+				cssCaches.splice(cssCaches.indexOf(cache), 1);
+				scheduleCSSCacheDisposal(cache);
+			} else disposeCSSCache(cache);
+			cache = void 0;
+		}
+	}
+	if (!cache) {
+		const plan = filename ? resolvePlan(workspaceDir, resolvedSettings.manifest) : {
+			manifest: resolvedSettings.manifest,
+			dependencies: []
+		};
+		const resolvedManifest = plan.manifest || defaultManifest;
+		const tooling = createToolingSessionSync({ manifest: resolvedManifest });
+		cache = {
+			cwd: workspaceDir,
+			manifest: resolvedSettings.manifest,
+			tooling,
+			configuredManifestSignature,
+			dependencies: plan.dependencies.map(stampDependency),
+			discovery,
+			references: 0
+		};
+		cssCaches.push(cache);
+	}
+	if (!sourceCache.cssCaches.includes(cache)) {
+		retainCSSCache(cache);
+		sourceCache.cssCaches.push(cache);
+	}
+	return cache.tooling;
+}
+function resolveContext(context) {
+	const sourceCode = context.sourceCode;
+	let sourceCache = sourceCaches.get(sourceCode);
+	if (!sourceCache) {
+		sourceCache = {
+			cssCaches: [],
+			references: 0,
+			workspaces: /* @__PURE__ */ new Map(),
+			tooling: []
+		};
+		sourceCaches.set(sourceCode, sourceCache);
+	}
+	sourceCache.references++;
+	const resolvedSettings = Object.assign({}, settings, context.settings?.["@master/css"]);
+	const cwd = context.cwd || process.cwd();
+	const filename = getContextFilename(context);
+	let facade = sourceCache.tooling.find((item) => item.cwd === cwd && item.filename === filename && item.manifest === resolvedSettings.manifest);
+	if (!facade) {
+		let session;
+		const source = sourceCache;
+		facade = {
+			cwd,
+			filename,
+			manifest: resolvedSettings.manifest,
+			...createSourceTooling(() => {
+				if (!source.references) throw new Error("The ESLint source context has been released.");
+				return session ??= resolveTooling(context, source, resolvedSettings);
+			})
+		};
+		sourceCache.tooling.push(facade);
+	}
+	let released = false;
+	return {
+		settings: resolvedSettings,
+		options: context.options[0] || {},
+		tooling: facade.session,
+		release() {
+			if (released) return;
+			released = true;
+			if (--sourceCache.references !== 0) return;
+			for (const cache of sourceCache.cssCaches) {
+				cache.references--;
+				scheduleCSSCacheDisposal(cache);
+			}
+			for (const snapshot of sourceCache.workspaces.values()) releaseWorkspaceSnapshot(snapshot);
+			for (const facade of sourceCache.tooling) facade.clear();
+			sourceCache.cssCaches.length = 0;
+			sourceCache.workspaces.clear();
+			sourceCache.tooling.length = 0;
+			sourceCaches.delete(sourceCode);
+		}
+	};
+}
+export { resolveContext as default };

package/dist/utils/source-tooling.d.ts

@@ -0,0 +1,7 @@
+import { MasterCSSToolingSession } from "@master/css-tooling";
+/** One facade per SourceCode/settings pair, never shared across autofix passes. */
+declare function createSourceTooling(getSession: () => MasterCSSToolingSession): {
+  session: MasterCSSToolingSession;
+  clear(): void;
+};
+export { createSourceTooling };

package/dist/utils/source-tooling.js

@@ -0,0 +1,40 @@
+// src/utils/source-tooling.ts
+const memoizedMethods = /* @__PURE__ */ new Set([
+	"analyzeLintDocument",
+	"analyzeLintClassList",
+	"tokenizeClassList",
+	"decodeHTMLAttribute"
+]);
+/** One facade per SourceCode/settings pair, never shared across autofix passes. */
+function createSourceTooling(getSession) {
+	const methods = /* @__PURE__ */ new Map();
+	const memoizedResults = [];
+	return {
+		session: new Proxy({}, { get(_, property) {
+			if (!memoizedMethods.has(property)) {
+				const session = getSession();
+				const value = Reflect.get(session, property, session);
+				return typeof value === "function" ? value.bind(session) : value;
+			}
+			let method = methods.get(property);
+			if (!method) {
+				const results = /* @__PURE__ */ new Map();
+				memoizedResults.push(results);
+				method = (...args) => {
+					const session = getSession();
+					const key = JSON.stringify(args);
+					if (!results.has(key)) results.set(key, Reflect.get(session, property).apply(session, args));
+					return results.get(key);
+				};
+				methods.set(property, method);
+			}
+			return method;
+		} }),
+		clear() {
+			for (const results of memoizedResults) results.clear();
+			memoizedResults.length = 0;
+			methods.clear();
+		}
+	};
+}
+export { createSourceTooling };

package/dist/utils/vue-literal.d.ts

@@ -0,0 +1,8 @@
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+declare function resolveVueLiteral(node: any, sourceCode: RuleContext<any, any[]>['sourceCode'], tooling: Pick<MasterCSSToolingSession, 'decodeHTMLAttribute'>): {
+  raw: string;
+  sourceRange(a: number, b: number): [number, number];
+  encode(text: string): string;
+};
+export { resolveVueLiteral };

package/dist/utils/vue-literal.js

@@ -0,0 +1,61 @@
+// src/utils/vue-literal.ts
+const attributes = /* @__PURE__ */ new WeakMap();
+function boundary(mapping, offset, from, end) {
+	if (offset === 0) return 0;
+	const to = from === "range" ? "sourceRange" : "range";
+	const last = mapping.spans.at(-1);
+	if (last && offset === last[from].end) return last[to].end;
+	let low = 0;
+	let high = mapping.spans.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		const limit = mapping.spans[middle][from].end;
+		if (limit < offset || !end && limit === offset) low = middle + 1;
+		else high = middle;
+	}
+	const span = mapping.spans[low];
+	if (!span || offset < span[from].start) return;
+	return span?.[to][end ? "end" : "start"];
+}
+function resolveVueLiteral(node, sourceCode, tooling) {
+	let container = node.parent;
+	while (container && container.type !== "VExpressionContainer") container = container.parent;
+	if (container?.parent?.type !== "VAttribute") return;
+	const [attributeStart, attributeEnd] = container.range;
+	const attribute = sourceCode.text.slice(attributeStart, attributeEnd);
+	const quote = attribute[0] === "\"" || attribute[0] === "'" ? attribute[0] : "";
+	const start = attributeStart + (quote ? 1 : 0);
+	const end = attributeEnd - (quote ? 1 : 0);
+	const text = sourceCode.text.slice(start, end);
+	let cached = attributes.get(container);
+	if (!cached || cached.text !== text) {
+		cached = {
+			text,
+			mapping: tooling.decodeHTMLAttribute(text)
+		};
+		attributes.set(container, cached);
+	}
+	const { mapping } = cached;
+	const from = boundary(mapping, node.range[0] - start, "sourceRange", false);
+	const to = boundary(mapping, node.range[1] - start, "sourceRange", true);
+	if (from === void 0 || to === void 0) return;
+	const raw = mapping.value.slice(from, to);
+	if (raw !== (node.type === "TemplateElement" ? "`" + node.value.raw + "`" : node.raw)) return;
+	return {
+		raw,
+		sourceRange(a, b) {
+			const first = boundary(mapping, from + a, "range", false);
+			const last = boundary(mapping, from + b, "range", true);
+			if (first === void 0 || last === void 0) throw new RangeError("Vue literal range is outside its HTML attribute.");
+			return [start + first, start + (a === b ? first : last)];
+		},
+		encode(text) {
+			return text.replace(quote ? /[&'"]/g : /[&'"<>=`\t\n\f\r ]/g, (character) => {
+				if (character === "&") return "&amp;";
+				if (!quote || character === quote) return `&#${character.charCodeAt(0)};`;
+				return character;
+			});
+		}
+	};
+}
+export { resolveVueLiteral };

package/dist/utils/with-context-release.d.ts

@@ -0,0 +1,3 @@
+import { RuleListener } from "@typescript-eslint/utils/ts-eslint";
+declare function withContextRelease(visitors: RuleListener, release: () => void): RuleListener;
+export { withContextRelease as default };

package/dist/utils/with-context-release.js

@@ -0,0 +1,15 @@
+// src/utils/with-context-release.ts
+function withContextRelease(visitors, release) {
+	const visitProgramExit = visitors["Program:exit"];
+	return {
+		...visitors,
+		"Program:exit"(node) {
+			try {
+				if (typeof visitProgramExit === "function") visitProgramExit(node);
+			} finally {
+				release();
+			}
+		}
+	};
+}
+export { withContextRelease as default };

package/dist/utils/with-visit-class-node.d.ts

@@ -0,0 +1,6 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { MasterCSSToolingSession } from "@master/css-tooling";
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import resolveClassNode from "./resolve-class-node.js";
+declare function withVisitClassNode(visit: (node: TSESTree.Node, resolved: ReturnType<typeof resolveClassNode>) => void, context: RuleContext<any, any[]>, lintSession: Pick<MasterCSSToolingSession, 'tokenizeClassList' | 'decodeHTMLAttribute'>): (node: any) => void;
+export { withVisitClassNode as default };

package/dist/utils/with-visit-class-node.js

@@ -0,0 +1,50 @@
+import resolveClassNode from "./resolve-class-node.js";
+// src/utils/with-visit-class-node.ts
+function withVisitClassNode(visit, context, lintSession) {
+	const visitNode = (node) => {
+		if (!node) return;
+		switch (node.type) {
+			case "BinaryExpression":
+			case "Identifier": return;
+			case "TemplateLiteral":
+				node.expressions?.forEach(visitNode);
+				node.quasis.forEach(visitNode);
+				return;
+			case "JSXExpressionContainer":
+				visitNode(node.expression);
+				return;
+			case "ConditionalExpression":
+				visitNode(node.consequent);
+				visitNode(node.alternate);
+				return;
+			case "ArrayExpression":
+				node.elements.forEach((el) => {
+					visitNode(el);
+				});
+				return;
+			case "LogicalExpression":
+				visitNode(node.right);
+				return;
+			case "ObjectExpression":
+				node.properties.forEach((prop) => {
+					visitNode(prop);
+				});
+				return;
+			case "Property":
+				if (node.shorthand) return;
+				if (node.value && [
+					"Literal",
+					"ArrayExpression",
+					"ObjectExpression"
+				].includes(node.value.type) && typeof node.value?.value !== "boolean") visitNode(node.value);
+				else if (node.key.type === "Literal") visitNode(node.key);
+				return;
+			default:
+				const resolved = resolveClassNode(node, context, lintSession);
+				if (!resolved) return;
+				visit(node, resolved);
+		}
+	};
+	return visitNode;
+}
+export { withVisitClassNode as default };

package/dist/utils/workspace-cache.d.ts

@@ -0,0 +1,11 @@
+import { DependencyStamp } from "./dependency-stamp.js";
+interface WorkspaceSnapshot {
+  cwd: string;
+  directories: readonly string[];
+  dependencies: readonly DependencyStamp[];
+  references: number;
+  disposeTimer?: ReturnType<typeof setTimeout>;
+}
+declare function acquireWorkspaceSnapshot(cwd: string): WorkspaceSnapshot;
+declare function releaseWorkspaceSnapshot(snapshot: WorkspaceSnapshot): void;
+export { WorkspaceSnapshot, acquireWorkspaceSnapshot, releaseWorkspaceSnapshot };

package/dist/utils/workspace-cache.js

@@ -0,0 +1,30 @@
+import { isDependencyCurrent, stampDependency } from "./dependency-stamp.js";
+import { discoverBuildWorkspaceDirectoriesSync } from "../internal/src/workspace-directories.js";
+import { discoverManifestEntriesSync } from "@master/css-compiler/project/sync";
+// src/utils/workspace-cache.ts
+const snapshots = /* @__PURE__ */ new Map();
+function acquireWorkspaceSnapshot(cwd) {
+	let snapshot = snapshots.get(cwd);
+	if (!snapshot || !snapshot.dependencies.every(isDependencyCurrent)) {
+		const dependencies = [];
+		snapshot = {
+			cwd,
+			directories: discoverBuildWorkspaceDirectoriesSync(cwd, discoverManifestEntriesSync({ root: cwd }), (file) => dependencies.push(stampDependency(file))),
+			dependencies,
+			references: 0
+		};
+		snapshots.set(cwd, snapshot);
+	}
+	if (snapshot.disposeTimer) clearTimeout(snapshot.disposeTimer);
+	snapshot.disposeTimer = void 0;
+	snapshot.references++;
+	return snapshot;
+}
+function releaseWorkspaceSnapshot(snapshot) {
+	if (--snapshot.references || snapshot.disposeTimer) return;
+	snapshot.disposeTimer = setTimeout(() => {
+		if (snapshots.get(snapshot.cwd) === snapshot) snapshots.delete(snapshot.cwd);
+	}, 1e3);
+	snapshot.disposeTimer.unref?.();
+}
+export { acquireWorkspaceSnapshot, releaseWorkspaceSnapshot };

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@master/eslint-plugin-css",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "keywords": [
+        "mastercss",
+        "eslint",
+        "eslintplugin"
+    ],
+    "license": "MIT",
+    "description": "Master CSS ESLint Plugin",
+    "author": "Aoyue Design LLC.",
+    "homepage": "https://css.master.co",
+    "bugs": {
+        "url": "https://github.com/master-co/css/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/eslint-plugin"
+    },
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-compiler": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-tooling": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-preset": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@typescript-eslint/utils": "^8.72.0",
+        "typescript-eslint": "^8.72.0"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}