tailwindcss-patch 9.0.1 → 9.1.0

package/dist/{validate-BI8356RT.mjs → validate-4FCU-Ql3.mjs}

@@ -9,14 +9,14 @@ import { createConsola } from "consola";
 import path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promises } from "node:fs";
+import postcss from "postcss";
 import * as t from "@babel/types";
 import generate from "@babel/generator";
 import _babelTraverse from "@babel/traverse";
 import { parse, parse as parse$1 } from "@babel/parser";
-import postcss from "postcss";
 import { loadConfig } from "tailwindcss-config";
 //#region package.json
-var version = "9.0.1";
+var version = "9.1.0";
 //#endregion
 //#region src/constants.ts
 const pkgName = "tailwindcss-patch";
@@ -1445,57 +1445,242 @@ async function loadPatchOptionsForWorkspace(cwd, overrides) {
 	return merge(overrides ?? {}, base, { projectRoot: cwd });
 }
 //#endregion
-//#region src/extraction/candidate-extractor.ts
-let nodeImportPromise;
-let oxideImportPromise;
+//#region src/v4/candidates.ts
+function resolveValidTailwindV4Candidates(designSystem, candidates) {
+	const validCandidates = /* @__PURE__ */ new Set();
+	const parsedCandidates = [];
+	for (const candidate of candidates) {
+		if (!candidate || parsedCandidates.includes(candidate)) continue;
+		if (designSystem.parseCandidate(candidate).length > 0) parsedCandidates.push(candidate);
+	}
+	if (parsedCandidates.length === 0) return validCandidates;
+	const cssByCandidate = designSystem.candidatesToCss(parsedCandidates);
+	for (let index = 0; index < parsedCandidates.length; index++) {
+		const candidate = parsedCandidates[index];
+		const candidateCss = cssByCandidate[index];
+		if (candidate && typeof candidateCss === "string" && candidateCss.trim().length > 0) validCandidates.add(candidate);
+	}
+	return validCandidates;
+}
+function splitTopLevel(value, separator) {
+	const result = [];
+	let start = 0;
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === ")" || character === "]" || character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth === 0 && character === separator) {
+			const item = value.slice(start, index).trim();
+			if (item) result.push(item);
+			start = index + 1;
+		}
+	}
+	const item = value.slice(start).trim();
+	if (item) result.push(item);
+	return result;
+}
+const sequencePattern = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function expandSequence(value) {
+	const match = value.match(sequencePattern);
+	if (!match) return [value];
+	const [, startValue, endValue, stepValue] = match;
+	if (startValue === void 0 || endValue === void 0) return [value];
+	const start = Number.parseInt(startValue, 10);
+	const end = Number.parseInt(endValue, 10);
+	let step = stepValue === void 0 ? start <= end ? 1 : -1 : Number.parseInt(stepValue, 10);
+	if (step === 0) throw new Error("Step cannot be zero in Tailwind CSS v4 inline source sequence.");
+	const ascending = start < end;
+	if (ascending && step < 0) step = -step;
+	if (!ascending && step > 0) step = -step;
+	const result = [];
+	for (let current = start; ascending ? current <= end : current >= end; current += step) result.push(current.toString());
+	return result;
+}
+function expandInlinePattern(pattern) {
+	const openIndex = pattern.indexOf("{");
+	if (openIndex === -1) return [pattern];
+	const prefix = pattern.slice(0, openIndex);
+	const rest = pattern.slice(openIndex);
+	let depth = 0;
+	let closeIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const character = rest[index];
+		if (character === "{") depth++;
+		else if (character === "}") {
+			depth--;
+			if (depth === 0) {
+				closeIndex = index;
+				break;
+			}
+		}
+	}
+	if (closeIndex === -1) throw new Error(`The Tailwind CSS v4 inline source pattern "${pattern}" is not balanced.`);
+	const body = rest.slice(1, closeIndex);
+	const suffix = rest.slice(closeIndex + 1);
+	const parts = sequencePattern.test(body) ? expandSequence(body) : splitTopLevel(body, ",").flatMap((part) => expandInlinePattern(part));
+	const suffixes = expandInlinePattern(suffix);
+	const result = [];
+	for (const part of parts) for (const expandedSuffix of suffixes) result.push(`${prefix}${part}${expandedSuffix}`);
+	return result;
+}
+function unquoteCssString(value) {
+	const quote = value[0];
+	if (quote !== "\"" && quote !== "'" || value[value.length - 1] !== quote) return;
+	let result = "";
+	for (let index = 1; index < value.length - 1; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			result += value[index] ?? "";
+			continue;
+		}
+		result += character;
+	}
+	return result;
+}
+function extractTailwindV4InlineSourceCandidates(css) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	postcss.parse(css).walkAtRules("source", (rule) => {
+		let params = rule.params.trim();
+		if (!params) return;
+		let negated = false;
+		if (params.startsWith("not ")) {
+			negated = true;
+			params = params.slice(4).trim();
+		}
+		if (!params.startsWith("inline(") || !params.endsWith(")")) return;
+		const inlineValue = unquoteCssString(params.slice(7, -1).trim());
+		if (inlineValue === void 0) return;
+		const target = negated ? excluded : included;
+		for (const part of splitTopLevel(inlineValue, " ")) for (const candidate of expandInlinePattern(part)) target.add(candidate);
+	});
+	return {
+		included,
+		excluded
+	};
+}
+//#endregion
+//#region src/v4/node-adapter.ts
+const nodeModulePromiseCache = /* @__PURE__ */ new Map();
 const designSystemPromiseCache = /* @__PURE__ */ new Map();
-const designSystemCandidateCache = /* @__PURE__ */ new Map();
-async function importNode() {
-	return import("@tailwindcss/node");
+function unique(values) {
+	return Array.from(new Set(Array.from(values).filter(Boolean).map((value) => path.resolve(value))));
 }
-async function importOxide() {
-	return import("@tailwindcss/oxide");
+function createRequireBase(base) {
+	return path.join(base, "package.json");
 }
-function getNodeModule() {
-	nodeImportPromise ??= importNode();
-	return nodeImportPromise;
+async function importResolvedModule(resolved) {
+	return import(pathToFileURL(resolved).href);
 }
-function getOxideModule() {
-	oxideImportPromise ??= importOxide();
-	return oxideImportPromise;
+async function importTailwindNodeFromBase(base) {
+	try {
+		return await importResolvedModule(createRequire(createRequireBase(base)).resolve("@tailwindcss/node"));
+	} catch {
+		return;
+	}
+}
+async function importFallbackTailwindNode() {
+	return import("@tailwindcss/node");
+}
+async function loadTailwindV4NodeModule(baseCandidates) {
+	const bases = unique(baseCandidates);
+	const cacheKey = JSON.stringify(bases);
+	const cached = nodeModulePromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const promise = (async () => {
+		for (const base of bases) {
+			const loaded = await importTailwindNodeFromBase(base);
+			if (loaded) return loaded;
+		}
+		return importFallbackTailwindNode();
+	})();
+	nodeModulePromiseCache.set(cacheKey, promise);
+	promise.catch(() => {
+		if (nodeModulePromiseCache.get(cacheKey) === promise) nodeModulePromiseCache.delete(cacheKey);
+	});
+	return promise;
 }
 function createDesignSystemCacheKey(css, bases) {
 	return JSON.stringify({
 		css,
-		bases: Array.from(new Set(bases.filter(Boolean)))
+		bases: unique(bases)
 	});
 }
-async function loadDesignSystem(css, bases) {
-	const uniqueBases = Array.from(new Set(bases.filter(Boolean)));
-	if (uniqueBases.length === 0) throw new Error("No base directories provided for Tailwind CSS design system.");
-	const cacheKey = createDesignSystemCacheKey(css, uniqueBases);
+function getTailwindV4DesignSystemCacheKey(source) {
+	return createDesignSystemCacheKey(source.css, [source.base, ...source.baseFallbacks]);
+}
+async function loadTailwindV4DesignSystem(source) {
+	const bases = unique([source.base, ...source.baseFallbacks]);
+	if (bases.length === 0) throw new Error("No base directories provided for Tailwind CSS v4 design system.");
+	const cacheKey = createDesignSystemCacheKey(source.css, bases);
 	const cached = designSystemPromiseCache.get(cacheKey);
 	if (cached) return cached;
 	const promise = (async () => {
-		const { __unstable__loadDesignSystem } = await getNodeModule();
+		const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
 		let lastError;
-		for (const base of uniqueBases) try {
-			return await __unstable__loadDesignSystem(css, { base });
+		for (const base of bases) try {
+			return await node.__unstable__loadDesignSystem(source.css, { base });
 		} catch (error) {
 			lastError = error;
 		}
 		if (lastError instanceof Error) throw lastError;
-		throw new Error("Failed to load Tailwind CSS design system.");
+		throw new Error("Failed to load Tailwind CSS v4 design system.");
 	})();
 	designSystemPromiseCache.set(cacheKey, promise);
 	promise.catch(() => {
-		if (designSystemPromiseCache.get(cacheKey) === promise) {
-			designSystemPromiseCache.delete(cacheKey);
-			designSystemCandidateCache.delete(cacheKey);
-		}
+		if (designSystemPromiseCache.get(cacheKey) === promise) designSystemPromiseCache.delete(cacheKey);
 	});
 	return promise;
 }
+async function compileTailwindV4Source(source) {
+	const node = await loadTailwindV4NodeModule([
+		source.projectRoot,
+		source.base,
+		...source.baseFallbacks
+	]);
+	const dependencies = new Set(source.dependencies);
+	return {
+		compiled: await node.compile(source.css, {
+			base: source.base,
+			onDependency(dependency) {
+				dependencies.add(path.resolve(dependency));
+			}
+		}),
+		dependencies
+	};
+}
+//#endregion
+//#region src/extraction/candidate-extractor.ts
+let oxideImportPromise;
+const designSystemCandidateCache = /* @__PURE__ */ new Map();
+async function importOxide() {
+	return import("@tailwindcss/oxide");
+}
+function getOxideModule() {
+	oxideImportPromise ??= importOxide();
+	return oxideImportPromise;
+}
 async function extractRawCandidatesWithPositions(content, extension = "html") {
 	const { Scanner } = await getOxideModule();
 	return new Scanner({}).getCandidatesWithPositions({
@@ -1526,8 +1711,15 @@ async function extractValidCandidates(options) {
 		pattern: source.pattern,
 		negated: source.negated
 	}));
-	const designSystemKey = createDesignSystemCacheKey(css, [base, ...baseFallbacks]);
-	const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks]);
+	const source = {
+		projectRoot: defaultCwd,
+		base,
+		baseFallbacks,
+		css,
+		dependencies: []
+	};
+	const designSystemKey = getTailwindV4DesignSystemCacheKey(source);
+	const designSystem = await loadTailwindV4DesignSystem(source);
 	const candidateCache = designSystemCandidateCache.get(designSystemKey) ?? /* @__PURE__ */ new Map();
 	designSystemCandidateCache.set(designSystemKey, candidateCache);
 	const candidates = await extractRawCandidates(sources);
@@ -1547,12 +1739,9 @@ async function extractValidCandidates(options) {
 		candidateCache.set(rawCandidate, false);
 	}
 	if (uncachedCandidates.length === 0) return validCandidates;
-	const cssByCandidate = designSystem.candidatesToCss(uncachedCandidates);
-	for (let index = 0; index < uncachedCandidates.length; index++) {
-		const candidate = uncachedCandidates[index];
-		if (candidate === void 0) continue;
-		const candidateCss = cssByCandidate[index];
-		const isValid = typeof candidateCss === "string" && candidateCss.trim().length > 0;
+	const validUncachedCandidates = resolveValidTailwindV4Candidates(designSystem, uncachedCandidates);
+	for (const candidate of uncachedCandidates) {
+		const isValid = validUncachedCandidates.has(candidate);
 		candidateCache.set(candidate, isValid);
 		if (!isValid) continue;
 		validCandidates.push(candidate);
@@ -3333,4 +3522,4 @@ var ValidateCommandError = class extends Error {
 	}
 };
 //#endregion
-export { normalizeOptions as C, loadWorkspaceConfigModule as S, logger as T, extractRawCandidates as _, tailwindcssPatchCommands as a, groupTokensByFile as b, MIGRATION_REPORT_KIND as c, getPatchStatusReport as d, runTailwindBuild as f, extractProjectCandidatesWithPositions as g, collectClassesFromTailwindV4 as h, classifyValidateError as i, MIGRATION_REPORT_SCHEMA_VERSION as l, collectClassesFromContexts as m, VALIDATE_FAILURE_REASONS as n, migrateConfigFiles as o, loadRuntimeContexts as p, ValidateCommandError as r, restoreConfigFiles as s, VALIDATE_EXIT_CODES as t, TailwindcssPatcher as u, extractRawCandidatesWithPositions as v, CacheStore as w, loadPatchOptionsForWorkspace as x, extractValidCandidates as y };
+export { extractTailwindV4InlineSourceCandidates as C, normalizeOptions as D, loadWorkspaceConfigModule as E, CacheStore as O, loadTailwindV4DesignSystem as S, loadPatchOptionsForWorkspace as T, extractRawCandidates as _, tailwindcssPatchCommands as a, groupTokensByFile as b, MIGRATION_REPORT_KIND as c, getPatchStatusReport as d, runTailwindBuild as f, extractProjectCandidatesWithPositions as g, collectClassesFromTailwindV4 as h, classifyValidateError as i, logger as k, MIGRATION_REPORT_SCHEMA_VERSION as l, collectClassesFromContexts as m, VALIDATE_FAILURE_REASONS as n, migrateConfigFiles as o, loadRuntimeContexts as p, ValidateCommandError as r, restoreConfigFiles as s, VALIDATE_EXIT_CODES as t, TailwindcssPatcher as u, extractRawCandidatesWithPositions as v, resolveValidTailwindV4Candidates as w, compileTailwindV4Source as x, extractValidCandidates as y };