tailwindcss-patch 9.0.1 → 9.2.0

package/dist/{validate-BI8356RT.mjs → validate-D5elFZMj.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.2.0";
 //#endregion
 //#region src/constants.ts
 const pkgName = "tailwindcss-patch";
@@ -1445,57 +1445,275 @@ 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;
+function isRelativeSpecifier(id) {
+	return id.startsWith("./") || id.startsWith("../") || id === "." || id === "..";
 }
-function getOxideModule() {
-	oxideImportPromise ??= importOxide();
-	return oxideImportPromise;
+function isAbsoluteSpecifier(id) {
+	return path.isAbsolute(id);
+}
+function isCssSpecifier(id) {
+	return path.extname(id) === ".css";
+}
+function createCssResolutionCandidates(id) {
+	if (isCssSpecifier(id)) return [id];
+	return [`${id}/index.css`, id];
+}
+function createFallbackCssResolver(baseCandidates) {
+	const bases = unique(baseCandidates);
+	return async (id) => {
+		if (isRelativeSpecifier(id) || isAbsoluteSpecifier(id)) return;
+		for (const base of bases) {
+			const requireFromBase = createRequire(createRequireBase(base));
+			for (const candidate of createCssResolutionCandidates(id)) try {
+				return requireFromBase.resolve(candidate);
+			} catch {}
+		}
+	};
+}
+async function importResolvedModule(resolved) {
+	return import(pathToFileURL(resolved).href);
+}
+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 bases = unique([source.base, ...source.baseFallbacks]);
+	if (bases.length === 0) throw new Error("No base directories provided for Tailwind CSS v4 compiler.");
+	const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
+	let lastError;
+	for (const base of bases) {
+		const dependencies = new Set(source.dependencies);
+		try {
+			return {
+				compiled: await node.compile(source.css, {
+					base,
+					customCssResolver: createFallbackCssResolver([source.projectRoot, ...bases]),
+					onDependency(dependency) {
+						dependencies.add(path.resolve(dependency));
+					}
+				}),
+				dependencies
+			};
+		} catch (error) {
+			lastError = error;
+		}
+	}
+	if (lastError instanceof Error) throw lastError;
+	throw new Error("Failed to compile Tailwind CSS v4 source.");
+}
+//#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 +1744,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 +1772,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 +3555,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss-patch",
-  "version": "9.0.1",
+  "version": "9.2.0",
   "description": "patch tailwindcss for exposing context and extract classes",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -71,7 +71,7 @@
     "fs-extra": "^11.3.4",
     "local-pkg": "^1.1.2",
     "pathe": "^2.0.3",
-    "postcss": "^8.5.13",
+    "postcss": "^8.5.14",
     "semver": "^7.7.4",
     "tailwindcss-config": "^1.1.5",
     "@tailwindcss-mangle/config": "7.0.1"

package/src/extraction/candidate-extractor.ts

@@ -8,78 +8,21 @@ import type {
 import { promises as fs } from 'node:fs'
 import process from 'node:process'
 import path from 'pathe'
+import { resolveValidTailwindV4Candidates } from '../v4/candidates'
+import { getTailwindV4DesignSystemCacheKey, loadTailwindV4DesignSystem } from '../v4/node-adapter'
 
-let nodeImportPromise: ReturnType<typeof importNode> | undefined
 let oxideImportPromise: ReturnType<typeof importOxide> | undefined
-const designSystemPromiseCache = new Map<string, Promise<any>>()
 const designSystemCandidateCache = new Map<string, Map<string, boolean>>()
 
-async function importNode() {
-  return import('@tailwindcss/node')
-}
-
 async function importOxide() {
   return import('@tailwindcss/oxide')
 }
 
-function getNodeModule() {
-  nodeImportPromise ??= importNode()
-  return nodeImportPromise
-}
-
 function getOxideModule() {
   oxideImportPromise ??= importOxide()
   return oxideImportPromise
 }
 
-function createDesignSystemCacheKey(css: string, bases: string[]) {
-  return JSON.stringify({
-    css,
-    bases: Array.from(new Set(bases.filter(Boolean))),
-  })
-}
-
-async function loadDesignSystem(css: string, bases: string[]) {
-  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)
-  const cached = designSystemPromiseCache.get(cacheKey)
-  if (cached) {
-    return cached
-  }
-
-  const promise = (async () => {
-    const { __unstable__loadDesignSystem } = await getNodeModule()
-    let lastError: unknown
-
-    for (const base of uniqueBases) {
-      try {
-        return await __unstable__loadDesignSystem(css, { base })
-      }
-      catch (error) {
-        lastError = error
-      }
-    }
-
-    if (lastError instanceof Error) {
-      throw lastError
-    }
-    throw new Error('Failed to load Tailwind CSS design system.')
-  })()
-
-  designSystemPromiseCache.set(cacheKey, promise)
-  promise.catch(() => {
-    if (designSystemPromiseCache.get(cacheKey) === promise) {
-      designSystemPromiseCache.delete(cacheKey)
-      designSystemCandidateCache.delete(cacheKey)
-    }
-  })
-  return promise
-}
-
 export interface ExtractValidCandidatesOption {
   sources?: SourceEntry[]
   base?: string
@@ -131,8 +74,15 @@ export async function extractValidCandidates(options?: ExtractValidCandidatesOpt
     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) ?? new Map<string, boolean>()
   designSystemCandidateCache.set(designSystemKey, candidateCache)
 
@@ -163,15 +113,10 @@ export async function extractValidCandidates(options?: ExtractValidCandidatesOpt
     return validCandidates
   }
 
-  const cssByCandidate = designSystem.candidatesToCss(uncachedCandidates)
+  const validUncachedCandidates = resolveValidTailwindV4Candidates(designSystem, uncachedCandidates)
 
-  for (let index = 0; index < uncachedCandidates.length; index++) {
-    const candidate = uncachedCandidates[index]
-    if (candidate === undefined) {
-      continue
-    }
-    const candidateCss = cssByCandidate[index]
-    const isValid = typeof candidateCss === 'string' && candidateCss.trim().length > 0
+  for (const candidate of uncachedCandidates) {
+    const isValid = validUncachedCandidates.has(candidate)
     candidateCache.set(candidate, isValid)
     if (!isValid) {
       continue

package/src/index.bundle.ts

@@ -33,6 +33,13 @@ import {
   runTailwindBuild,
 } from './install'
 import logger from './logger'
+import {
+  createTailwindV4Engine,
+  loadTailwindV4DesignSystem,
+  resolveTailwindV4Source,
+  resolveTailwindV4SourceFromPatchOptions,
+  resolveValidTailwindV4Candidates,
+} from './v4'
 
 const require = createRequire(import.meta.url)
 
@@ -46,6 +53,7 @@ export {
   CacheStore,
   collectClassesFromContexts,
   collectClassesFromTailwindV4,
+  createTailwindV4Engine,
   extractProjectCandidatesWithPositions,
   extractRawCandidates,
   extractRawCandidatesWithPositions,
@@ -53,11 +61,15 @@ export {
   getPatchStatusReport,
   groupTokensByFile,
   loadRuntimeContexts,
+  loadTailwindV4DesignSystem,
   logger,
   migrateConfigFiles,
   MIGRATION_REPORT_KIND,
   MIGRATION_REPORT_SCHEMA_VERSION,
   normalizeOptions,
+  resolveTailwindV4Source,
+  resolveTailwindV4SourceFromPatchOptions,
+  resolveValidTailwindV4Candidates,
   restoreConfigFiles,
   runTailwindBuild,
   tailwindcssPatchCommands,
@@ -91,6 +103,15 @@ export type {
 } from './commands/validate'
 export type { TailwindCssPatchOptions } from './config'
 export * from './types'
+export type {
+  TailwindV4CandidateSource,
+  TailwindV4DesignSystem,
+  TailwindV4Engine,
+  TailwindV4GenerateOptions,
+  TailwindV4GenerateResult,
+  TailwindV4ResolvedSource,
+  TailwindV4SourceOptions,
+} from './v4'
 
 export function mountTailwindcssPatchCommands(cli: CAC, options: TailwindcssPatchCliMountOptions = {}) {
   return loadCliModule().mountTailwindcssPatchCommands(cli, options)

package/src/index.ts

@@ -51,6 +51,22 @@ export {
 } from './install'
 export { default as logger } from './logger'
 export * from './types'
+export {
+  createTailwindV4Engine,
+  loadTailwindV4DesignSystem,
+  resolveTailwindV4Source,
+  resolveTailwindV4SourceFromPatchOptions,
+  resolveValidTailwindV4Candidates,
+} from './v4'
+export type {
+  TailwindV4CandidateSource,
+  TailwindV4DesignSystem,
+  TailwindV4Engine,
+  TailwindV4GenerateOptions,
+  TailwindV4GenerateResult,
+  TailwindV4ResolvedSource,
+  TailwindV4SourceOptions,
+} from './v4'
 
 export function defineConfig<T extends TailwindcssMangleConfig>(config: T): T {
   return config