tailwindcss-patch 9.0.0 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss-patch",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "patch tailwindcss for exposing context and extract classes",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -62,31 +62,31 @@
   },
   "dependencies": {
     "@babel/generator": "^7.29.1",
-    "@babel/parser": "^7.29.2",
+    "@babel/parser": "^7.29.3",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@tailwindcss/node": "^4.2.2",
+    "@tailwindcss/node": "^4.2.4",
     "cac": "6.7.14",
     "consola": "^3.4.2",
     "fs-extra": "^11.3.4",
     "local-pkg": "^1.1.2",
     "pathe": "^2.0.3",
-    "postcss": "^8.5.8",
+    "postcss": "^8.5.14",
     "semver": "^7.7.4",
-    "tailwindcss-config": "^1.1.4",
-    "@tailwindcss-mangle/config": "7.0.0"
+    "tailwindcss-config": "^1.1.5",
+    "@tailwindcss-mangle/config": "7.0.1"
   },
   "devDependencies": {
-    "@tailwindcss/oxide": "^4.2.2",
-    "@tailwindcss/postcss": "^4.2.2",
-    "@tailwindcss/vite": "^4.2.2",
+    "@tailwindcss/oxide": "^4.2.4",
+    "@tailwindcss/postcss": "^4.2.4",
+    "@tailwindcss/vite": "^4.2.4",
     "tailwindcss": "^4.1.18",
     "tailwindcss-3": "npm:tailwindcss@^3.4.19",
     "tailwindcss-4": "npm:tailwindcss@^4.1.18"
   },
   "scripts": {
-    "dev": "tsup --watch --sourcemap",
-    "build": "tsup",
+    "dev": "tsdown --watch --sourcemap",
+    "build": "tsdown",
     "test": "vitest run",
     "test:types": "pnpm build && tsd --typings dist/index.d.mts --files test-d/**/*.test-d.ts",
     "test:dev": "vitest",

package/src/api/tailwindcss-patcher.ts

@@ -1,6 +1,7 @@
 import type { SourceEntry } from '@tailwindcss/oxide'
 import type { PackageInfo } from 'local-pkg'
 import type { NormalizedTailwindCssPatchOptions } from '../config'
+import type { PatchResult, TailwindCollector, TailwindMajorVersion } from '../runtime/collector'
 import type {
   CacheClearOptions,
   CacheClearResult,
@@ -12,6 +13,7 @@ import type {
   TailwindTokenFileKey,
   TailwindTokenReport,
 } from '../types'
+import { createRequire } from 'node:module'
 import process from 'node:process'
 import fs from 'fs-extra'
 import { getPackageInfoSync } from 'local-pkg'
@@ -27,8 +29,7 @@ import {
 } from '../extraction/candidate-extractor'
 import { collectClassesFromContexts } from '../install/class-collector'
 import logger from '../logger'
-import { RuntimeCollector, TailwindV4Collector, type PatchResult, type TailwindCollector, type TailwindMajorVersion } from '../runtime/collector'
-
+import { RuntimeCollector, TailwindV4Collector } from '../runtime/collector'
 
 interface PatchMemo {
   result: PatchResult
@@ -103,6 +104,35 @@ function createCollector(
   return new RuntimeCollector(packageInfo, options, majorVersion, snapshotFactory)
 }
 
+function getPackageInfoFromCwd(packageName: string, cwd: string): PackageInfo | undefined {
+  try {
+    const packageJsonPath = createRequire(path.join(cwd, 'package.json')).resolve(`${packageName}/package.json`)
+    const packageJson = fs.readJSONSync(packageJsonPath) as PackageInfo['packageJson']
+    return {
+      name: packageName,
+      version: typeof packageJson.version === 'string' ? packageJson.version : undefined,
+      rootPath: path.dirname(packageJsonPath),
+      packageJsonPath,
+      packageJson,
+    } as PackageInfo
+  }
+  catch {
+    return undefined
+  }
+}
+
+function getTailwindPackageInfo(options: NormalizedTailwindCssPatchOptions) {
+  const cwd = options.tailwind.cwd ?? options.projectRoot
+  const cwdPackageInfo = options.tailwind.resolve?.paths?.length
+    ? getPackageInfoFromCwd(options.tailwind.packageName, cwd)
+    : undefined
+  return cwdPackageInfo
+    ?? getPackageInfoSync(
+      options.tailwind.packageName,
+      options.tailwind.resolve,
+    )
+}
+
 export class TailwindcssPatcher {
   public readonly options: NormalizedTailwindCssPatchOptions
   public readonly packageInfo: PackageInfo
@@ -119,10 +149,7 @@ export class TailwindcssPatcher {
 
   constructor(options: TailwindCssPatchOptions = {}) {
     this.options = normalizeOptions(options)
-    const packageInfo = getPackageInfoSync(
-      this.options.tailwind.packageName,
-      this.options.tailwind.resolve,
-    )
+    const packageInfo = getTailwindPackageInfo(this.options)
 
     if (!packageInfo) {
       throw new Error(`Unable to locate Tailwind CSS package "${this.options.tailwind.packageName}".`)

package/src/commands/basic-handlers.ts

@@ -5,7 +5,6 @@ import type { TailwindcssPatchCommandContext } from './types'
 import process from 'node:process'
 import fs from 'fs-extra'
 import path from 'pathe'
-import { TailwindcssPatcher } from '../api/tailwindcss-patcher'
 import { loadWorkspaceConfigModule } from '../config/workspace'
 import { groupTokensByFile } from '../extraction/candidate-extractor'
 import logger from '../logger'

package/src/config/index.ts

@@ -7,9 +7,9 @@ export type {
   ExposeContextOptions,
   ExtendLengthUnitsOptions,
   ExtractOptions,
-  NormalizedTailwindCssPatchOptions,
   NormalizedCacheOptions,
   NormalizedExtendLengthUnitsOptions,
+  NormalizedTailwindCssPatchOptions,
   TailwindCssOptions,
   TailwindCssPatchOptions,
   TailwindV2Options,

package/src/config/workspace.ts

@@ -82,6 +82,6 @@ export async function loadPatchOptionsForWorkspace(cwd: string, overrides?: Tail
   const base = config?.registry
     ? fromUnifiedConfig(config.registry)
     : {}
-  const merged = merge(overrides ?? {}, base) as TailwindCssPatchOptions
+  const merged = merge(overrides ?? {}, base, { projectRoot: cwd }) as TailwindCssPatchOptions
   return merged
 }

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

package/src/options/legacy.ts

@@ -19,7 +19,7 @@ type DeprecatedTailwindKey = keyof typeof deprecatedTailwindMapping
 
 function assertNoDeprecatedRegistryOptions(registry: RegistryOptions) {
   const usedRegistryKeys = (Object.keys(deprecatedRegistryMapping) as DeprecatedRegistryKey[])
-    .filter(key => Object.prototype.hasOwnProperty.call(registry, key))
+    .filter(key => Object.hasOwn(registry, key))
 
   if (usedRegistryKeys.length > 0) {
     const mapping = usedRegistryKeys.map(key => `${key} -> ${deprecatedRegistryMapping[key]}`).join(', ')
@@ -34,7 +34,7 @@ function assertNoDeprecatedRegistryOptions(registry: RegistryOptions) {
   }
 
   const usedTailwindKeys = (Object.keys(deprecatedTailwindMapping) as DeprecatedTailwindKey[])
-    .filter(key => Object.prototype.hasOwnProperty.call(tailwind, key))
+    .filter(key => Object.hasOwn(tailwind, key))
 
   if (usedTailwindKeys.length > 0) {
     const mapping = usedTailwindKeys.map(key => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(', ')

package/src/options/normalize.ts

@@ -1,14 +1,14 @@
 import type { ILengthUnitsPatchOptions } from '../types'
 import type {
+  ApplyOptions,
   CacheDriver,
   CacheStrategy,
-  ApplyOptions,
   ExtractOptions,
   NormalizedCacheOptions,
-  NormalizedTailwindCssPatchOptions,
   NormalizedFeatureOptions,
   NormalizedOutputOptions,
   NormalizedTailwindConfigOptions,
+  NormalizedTailwindCssPatchOptions,
   NormalizedTailwindV4Options,
   TailwindCssOptions,
   TailwindCssPatchOptions,
@@ -176,12 +176,13 @@ function normalizeTailwindV4Options(
 function normalizeTailwindOptions(
   tailwind: TailwindCssOptions | undefined,
   projectRoot: string,
+  shouldDefaultResolveFromCwd: boolean,
 ): NormalizedTailwindConfigOptions {
   const packageName = tailwind?.packageName ?? 'tailwindcss'
   const versionHint = tailwind?.version
-  const resolve = tailwind?.resolve
 
   const cwd = tailwind?.cwd ?? projectRoot
+  const resolve = tailwind?.resolve ?? (shouldDefaultResolveFromCwd ? { paths: [cwd] } : undefined)
   const config = tailwind?.config
   const postcssPlugin = tailwind?.postcssPlugin
 
@@ -212,7 +213,7 @@ type DeprecatedTopLevelOptionKey = keyof typeof deprecatedOptionMapping
 
 function assertNoDeprecatedOptions(options: TailwindCssPatchOptions) {
   const used = (Object.keys(deprecatedOptionMapping) as DeprecatedTopLevelOptionKey[])
-    .filter(key => Object.prototype.hasOwnProperty.call(options, key))
+    .filter(key => Object.hasOwn(options, key))
 
   if (used.length === 0) {
     return
@@ -232,7 +233,11 @@ export function normalizeOptions(options: TailwindCssPatchOptions = {}): Normali
 
   const output = normalizeOutputOptions(options.extract)
   const cache = normalizeCacheOptions(options.cache, projectRoot)
-  const tailwind = normalizeTailwindOptions(options.tailwindcss, projectRoot)
+  const tailwind = normalizeTailwindOptions(
+    options.tailwindcss,
+    projectRoot,
+    options.projectRoot !== undefined || options.tailwindcss?.cwd !== undefined,
+  )
   const exposeContext = normalizeExposeContextOptions(options.apply?.exposeContext)
   const extendLengthUnits = normalizeExtendLengthUnitsOptions(options.apply?.extendLengthUnits)
 

package/src/runtime/collector.ts

@@ -1,7 +1,7 @@
 import type { PackageInfo } from 'local-pkg'
 import type { NormalizedTailwindCssPatchOptions } from '../config'
-import type { PatchStatusReport, TailwindcssRuntimeContext } from '../types'
 import type { applyTailwindPatches } from '../install/patch-runner'
+import type { PatchStatusReport, TailwindcssRuntimeContext } from '../types'
 import { collectClassesFromContexts, collectClassesFromTailwindV4 } from '../install/class-collector'
 import { loadRuntimeContexts } from '../install/context-registry'
 import { applyTailwindPatches as runPatch } from '../install/patch-runner'
@@ -12,12 +12,12 @@ export type TailwindMajorVersion = 2 | 3 | 4
 export type PatchResult = ReturnType<typeof applyTailwindPatches>
 
 export interface TailwindCollector {
-  patch(): Promise<PatchResult>
-  getPatchStatus(): Promise<PatchStatusReport>
-  collectClassSet(): Promise<Set<string>>
-  getContexts(): TailwindcssRuntimeContext[]
-  getPatchSnapshot(): string
-  runTailwindBuildIfNeeded?(): Promise<void>
+  patch: () => Promise<PatchResult>
+  getPatchStatus: () => Promise<PatchStatusReport>
+  collectClassSet: () => Promise<Set<string>>
+  getContexts: () => TailwindcssRuntimeContext[]
+  getPatchSnapshot: () => string
+  runTailwindBuildIfNeeded?: () => Promise<void>
 }
 
 function resolveTailwindExecutionOptions(

package/src/runtime/process-tailwindcss.ts

@@ -4,7 +4,7 @@ import path from 'pathe'
 import postcss from 'postcss'
 import { loadConfig } from 'tailwindcss-config'
 
-const require = createRequire(import.meta.url)
+type NodeRequire = ReturnType<typeof createRequire>
 
 export interface TailwindBuildOptions {
   cwd: string
@@ -13,8 +13,12 @@ export interface TailwindBuildOptions {
   postcssPlugin?: string
 }
 
-function resolveModuleEntry(id: string) {
-  return path.isAbsolute(id) ? id : require.resolve(id)
+function createCwdRequire(cwd: string) {
+  return createRequire(path.join(cwd, 'package.json'))
+}
+
+function resolveModuleEntry(id: string, moduleRequire: NodeRequire) {
+  return path.isAbsolute(id) ? id : moduleRequire.resolve(id)
 }
 
 function resolvePackageRootFromEntry(entry: string) {
@@ -29,9 +33,18 @@ function resolvePackageRootFromEntry(entry: string) {
   return undefined
 }
 
-function clearTailwindV3RuntimeState(pluginName: string) {
+function resolveCacheKey(moduleRequire: NodeRequire, entry: string) {
   try {
-    const entry = resolveModuleEntry(pluginName)
+    return moduleRequire.resolve(entry)
+  }
+  catch {
+    return entry
+  }
+}
+
+function clearTailwindV3RuntimeState(pluginName: string, moduleRequire: NodeRequire) {
+  try {
+    const entry = resolveModuleEntry(pluginName, moduleRequire)
     const root = resolvePackageRootFromEntry(entry)
     if (!root) {
       return
@@ -42,13 +55,14 @@ function clearTailwindV3RuntimeState(pluginName: string) {
       return
     }
 
-    const sharedState = require.cache[sharedStatePath]?.exports as
+    const sharedStateKey = resolveCacheKey(moduleRequire, sharedStatePath)
+    const sharedState = moduleRequire.cache[sharedStateKey]?.exports as
       | {
-      contextMap?: Map<unknown, unknown>
-      configContextMap?: Map<unknown, unknown>
-      contextSourcesMap?: Map<unknown, unknown>
-      sourceHashMap?: Map<unknown, unknown>
-    }
+        contextMap?: Map<unknown, unknown>
+        configContextMap?: Map<unknown, unknown>
+        contextSourcesMap?: Map<unknown, unknown>
+        sourceHashMap?: Map<unknown, unknown>
+      }
       | undefined
     sharedState?.contextMap?.clear()
     sharedState?.configContextMap?.clear()
@@ -61,10 +75,11 @@ function clearTailwindV3RuntimeState(pluginName: string) {
         continue
       }
 
-      const runtimeModule = require.cache[runtimeEntry]?.exports as
+      const runtimeKey = resolveCacheKey(moduleRequire, runtimeEntry)
+      const runtimeModule = moduleRequire.cache[runtimeKey]?.exports as
         | {
-        contextRef?: { value?: unknown[] }
-      }
+          contextRef?: { value?: unknown[] }
+        }
         | undefined
       runtimeModule?.contextRef?.value?.splice(0, runtimeModule.contextRef.value.length)
       break
@@ -90,14 +105,15 @@ async function resolveConfigPath(options: TailwindBuildOptions) {
 export async function runTailwindBuild(options: TailwindBuildOptions) {
   const configPath = await resolveConfigPath(options)
   const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? '@tailwindcss/postcss' : 'tailwindcss')
+  const moduleRequire = createCwdRequire(options.cwd)
 
   if (options.majorVersion === 3) {
-    clearTailwindV3RuntimeState(pluginName)
+    clearTailwindV3RuntimeState(pluginName, moduleRequire)
   }
 
   if (options.majorVersion === 4) {
     return postcss([
-      require(pluginName)({
+      moduleRequire(pluginName)({
         config: configPath,
       }),
     ]).process('@import \'tailwindcss\';', {
@@ -106,7 +122,7 @@ export async function runTailwindBuild(options: TailwindBuildOptions) {
   }
 
   return postcss([
-    require(pluginName)({
+    moduleRequire(pluginName)({
       config: configPath,
     }),
   ]).process('@tailwind base;@tailwind components;@tailwind utilities;', {