tailwindcss-patch 9.0.1 → 9.1.0

package/dist/{validate-B8H-8rWO.js → validate-BuhhSYBe.js}

@@ -12,6 +12,8 @@ let node_crypto = require("node:crypto");
 let consola = require("consola");
 let node_url = require("node:url");
 let node_fs = require("node:fs");
+let postcss = require("postcss");
+postcss = require_chunk.__toESM(postcss);
 let _babel_types = require("@babel/types");
 _babel_types = require_chunk.__toESM(_babel_types);
 let _babel_generator = require("@babel/generator");
@@ -19,11 +21,9 @@ _babel_generator = require_chunk.__toESM(_babel_generator);
 let _babel_traverse = require("@babel/traverse");
 _babel_traverse = require_chunk.__toESM(_babel_traverse);
 let _babel_parser = require("@babel/parser");
-let postcss = require("postcss");
-postcss = require_chunk.__toESM(postcss);
 let tailwindcss_config = require("tailwindcss-config");
 //#region package.json
-var version = "9.0.1";
+var version = "9.1.0";
 //#endregion
 //#region src/constants.ts
 const pkgName = "tailwindcss-patch";
@@ -1447,57 +1447,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.default.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) => pathe.default.resolve(value))));
 }
-async function importOxide() {
-	return import("@tailwindcss/oxide");
+function createRequireBase(base) {
+	return pathe.default.join(base, "package.json");
 }
-function getNodeModule() {
-	nodeImportPromise ??= importNode();
-	return nodeImportPromise;
+async function importResolvedModule(resolved) {
+	return import((0, node_url.pathToFileURL)(resolved).href);
 }
-function getOxideModule() {
-	oxideImportPromise ??= importOxide();
-	return oxideImportPromise;
+async function importTailwindNodeFromBase(base) {
+	try {
+		return await importResolvedModule((0, node_module.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(pathe.default.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({
@@ -1528,8 +1713,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);
@@ -1549,12 +1741,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);
@@ -3395,6 +3584,12 @@ Object.defineProperty(exports, "collectClassesFromTailwindV4", {
 		return collectClassesFromTailwindV4;
 	}
 });
+Object.defineProperty(exports, "compileTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return compileTailwindV4Source;
+	}
+});
 Object.defineProperty(exports, "extractProjectCandidatesWithPositions", {
 	enumerable: true,
 	get: function() {
@@ -3413,6 +3608,12 @@ Object.defineProperty(exports, "extractRawCandidatesWithPositions", {
 		return extractRawCandidatesWithPositions;
 	}
 });
+Object.defineProperty(exports, "extractTailwindV4InlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return extractTailwindV4InlineSourceCandidates;
+	}
+});
 Object.defineProperty(exports, "extractValidCandidates", {
 	enumerable: true,
 	get: function() {
@@ -3443,6 +3644,12 @@ Object.defineProperty(exports, "loadRuntimeContexts", {
 		return loadRuntimeContexts;
 	}
 });
+Object.defineProperty(exports, "loadTailwindV4DesignSystem", {
+	enumerable: true,
+	get: function() {
+		return loadTailwindV4DesignSystem;
+	}
+});
 Object.defineProperty(exports, "loadWorkspaceConfigModule", {
 	enumerable: true,
 	get: function() {
@@ -3467,6 +3674,12 @@ Object.defineProperty(exports, "normalizeOptions", {
 		return normalizeOptions;
 	}
 });
+Object.defineProperty(exports, "resolveValidTailwindV4Candidates", {
+	enumerable: true,
+	get: function() {
+		return resolveValidTailwindV4Candidates;
+	}
+});
 Object.defineProperty(exports, "restoreConfigFiles", {
 	enumerable: true,
 	get: function() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss-patch",
-  "version": "9.0.1",
+  "version": "9.1.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