tailwindcss-patch 9.3.6 → 9.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss-patch",
-  "version": "9.3.6",
+  "version": "9.3.7",
   "description": "patch tailwindcss for exposing context and extract classes",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -71,6 +71,7 @@
     "consola": "^3.4.2",
     "fs-extra": "^11.3.5",
     "local-pkg": "^1.2.1",
+    "micromatch": "^4.0.8",
     "pathe": "^2.0.3",
     "postcss": "^8.5.15",
     "semver": "^7.8.1",

package/src/extraction/candidate-extractor.ts

@@ -14,6 +14,10 @@ import {
 } from '../v4/bare-arbitrary-values'
 import { extractTailwindV4InlineSourceCandidates, resolveValidTailwindV4Candidates } from '../v4/candidates'
 import { compileTailwindV4Source, getTailwindV4DesignSystemCacheKey, loadTailwindV4DesignSystem } from '../v4/node-adapter'
+import {
+  createTailwindV4CompiledSourceEntries,
+  normalizeTailwindV4ScannerSources,
+} from '../v4/source-scan'
 
 let oxideImportPromise: ReturnType<typeof importOxide> | undefined
 const designSystemCandidateCache = new Map<string, Map<string, boolean>>()
@@ -507,99 +511,12 @@ export interface ResolveProjectSourceFilesOptions {
   filter?: (file: string) => boolean
 }
 
-function expandBracePattern(pattern: string) {
-  const index = pattern.indexOf('{')
-  if (index === -1) {
-    return [pattern]
-  }
-
-  const rest = pattern.slice(index)
-  let depth = 0
-  let endIndex = -1
-  for (let i = 0; i < rest.length; i++) {
-    const char = rest[i]
-    if (char === '\\') {
-      i += 1
-      continue
-    }
-    if (char === '{') {
-      depth += 1
-      continue
-    }
-    if (char === '}') {
-      depth -= 1
-      if (depth === 0) {
-        endIndex = i
-        break
-      }
-    }
-  }
-  if (endIndex === -1) {
-    return [pattern]
-  }
-
-  const prefix = pattern.slice(0, index)
-  const inner = rest.slice(1, endIndex)
-  const suffix = rest.slice(endIndex + 1)
-  const parts: string[] = []
-  const stack: string[] = []
-  let lastPos = 0
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i]
-    if (char === '\\') {
-      i += 1
-      continue
-    }
-    if (char === '{') {
-      stack.push('}')
-      continue
-    }
-    if (char === '}' && stack[stack.length - 1] === '}') {
-      stack.pop()
-      continue
-    }
-    if (char === ',' && stack.length === 0) {
-      parts.push(inner.slice(lastPos, i))
-      lastPos = i + 1
-    }
-  }
-  parts.push(inner.slice(lastPos))
-
-  return parts.flatMap(part =>
-    expandBracePattern(`${prefix}${part}${suffix}`))
-}
-
-function normalizeScannerSources(
-  sources: SourceEntry[] | undefined,
-  cwd: string,
-  ignoredSources: SourceEntry[] = [],
-) {
-  const baseSources = sources?.length
-    ? sources
-    : [
-        {
-          base: cwd,
-          pattern: '**/*',
-          negated: false,
-        },
-      ]
-
-  return [...baseSources, ...ignoredSources].flatMap((source) => {
-    const base = source.base ?? cwd
-    return expandBracePattern(source.pattern).map(pattern => ({
-      base,
-      pattern,
-      negated: source.negated,
-    }))
-  })
-}
-
 async function resolveScannerSources(options?: ResolveProjectSourceFilesOptions) {
   const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd()
   if (options?.sources?.length || options?.css === undefined) {
     return {
       cwd,
-      sources: normalizeScannerSources(options?.sources, cwd, options?.ignoredSources),
+      sources: normalizeTailwindV4ScannerSources(options?.sources, cwd, options?.ignoredSources),
     }
   }
 
@@ -611,19 +528,13 @@ async function resolveScannerSources(options?: ResolveProjectSourceFilesOptions)
     css: options.css,
     dependencies: [],
   })
-  const rootSources = (() => {
-    if (compiled.root === 'none') {
-      return []
-    }
-    if (compiled.root === null) {
-      return [{ base, pattern: '**/*', negated: false }]
-    }
-    return [{ ...compiled.root, negated: false }]
-  })()
-
   return {
     cwd,
-    sources: normalizeScannerSources([...rootSources, ...compiled.sources], cwd, options.ignoredSources),
+    sources: normalizeTailwindV4ScannerSources(
+      createTailwindV4CompiledSourceEntries(compiled.root, compiled.sources, base),
+      cwd,
+      options.ignoredSources,
+    ),
   }
 }
 

package/src/index.ts

@@ -56,14 +56,34 @@ export {
 export { default as logger } from './logger'
 export * from './types'
 export {
+  createTailwindV4CompiledSourceEntries,
   createTailwindV4Engine,
+  createTailwindV4DefaultIgnoreSources,
+  createTailwindV4RootSources,
+  createTailwindV4SourceEntryMatcher,
+  createTailwindV4SourceExclusionMatcher,
+  expandTailwindV4SourceEntries,
+  expandTailwindV4SourceEntryBraces,
+  isFileExcludedByTailwindV4SourceEntries,
+  isFileMatchedByTailwindV4SourceEntries,
   loadTailwindV4DesignSystem,
+  mergeTailwindV4SourceEntries,
+  normalizeTailwindV4ScannerSources,
+  normalizeTailwindV4SourceEntries,
+  resolveSourceScanPath,
   resolveTailwindV4Source,
+  resolveTailwindV4SourceBaseCandidates,
+  resolveTailwindV4SourceEntry,
   resolveTailwindV4SourceFromPatchOptions,
   resolveValidTailwindV4Candidates,
+  TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+  TAILWIND_V4_IGNORED_CONTENT_DIRS,
+  TAILWIND_V4_IGNORED_EXTENSIONS,
+  TAILWIND_V4_IGNORED_FILES,
 } from './v4'
 export type {
   TailwindV4CandidateSource,
+  TailwindV4CompiledSourceRoot,
   TailwindV4CssSource,
   TailwindV4DesignSystem,
   TailwindV4Engine,
@@ -71,6 +91,7 @@ export type {
   TailwindV4GenerateResult,
   TailwindV4ResolvedSource,
   TailwindV4SourceOptions,
+  TailwindV4SourcePattern,
 } from './v4'
 
 export function defineConfig<T extends TailwindcssMangleConfig>(config: T): T {

package/src/v4/engine.ts

@@ -13,6 +13,7 @@ import {
   resolveValidTailwindV4Candidates,
 } from './candidates'
 import { compileTailwindV4Source, loadTailwindV4DesignSystem } from './node-adapter'
+import { createTailwindV4CompiledSourceEntries } from './source-scan'
 
 function resolveScanSources(
   options: TailwindV4GenerateOptions | undefined,
@@ -24,16 +25,7 @@ function resolveScanSources(
     return options.scanSources
   }
   if (options?.scanSources === true) {
-    const rootSources = (() => {
-      if (compiledRoot === 'none') {
-        return []
-      }
-      if (compiledRoot === null) {
-        return [{ base: source.base, pattern: '**/*', negated: false }]
-      }
-      return [{ ...compiledRoot, negated: false }]
-    })()
-    return [...rootSources, ...compiledSources]
+    return createTailwindV4CompiledSourceEntries(compiledRoot, compiledSources, source.base)
   }
   return []
 }

package/src/v4/index.ts

@@ -8,6 +8,27 @@ export {
   loadTailwindV4DesignSystem,
   loadTailwindV4NodeModule,
 } from './node-adapter'
+export {
+  createTailwindV4CompiledSourceEntries,
+  createTailwindV4DefaultIgnoreSources,
+  createTailwindV4RootSources,
+  createTailwindV4SourceEntryMatcher,
+  createTailwindV4SourceExclusionMatcher,
+  expandTailwindV4SourceEntries,
+  expandTailwindV4SourceEntryBraces,
+  isFileExcludedByTailwindV4SourceEntries,
+  isFileMatchedByTailwindV4SourceEntries,
+  mergeTailwindV4SourceEntries,
+  normalizeTailwindV4ScannerSources,
+  normalizeTailwindV4SourceEntries,
+  resolveSourceScanPath,
+  resolveTailwindV4SourceBaseCandidates,
+  resolveTailwindV4SourceEntry,
+  TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+  TAILWIND_V4_IGNORED_CONTENT_DIRS,
+  TAILWIND_V4_IGNORED_EXTENSIONS,
+  TAILWIND_V4_IGNORED_FILES,
+} from './source-scan'
 export {
   resolveTailwindV4Source,
   resolveTailwindV4SourceFromPatchOptions,
@@ -15,6 +36,7 @@ export {
 } from './source'
 export type {
   TailwindV4CandidateSource,
+  TailwindV4CompiledSourceRoot,
   TailwindV4CssSource,
   TailwindV4DesignSystem,
   TailwindV4Engine,

package/src/v4/node-adapter.ts

@@ -1,6 +1,7 @@
 import type {
   TailwindV4DesignSystem,
   TailwindV4ResolvedSource,
+  TailwindV4CompiledSourceRoot,
   TailwindV4SourcePattern,
 } from './types'
 import { createRequire } from 'node:module'
@@ -9,10 +10,7 @@ import path from 'pathe'
 
 interface TailwindV4CompiledSource {
   sources: TailwindV4SourcePattern[]
-  root: null | 'none' | {
-    base: string
-    pattern: string
-  }
+  root: TailwindV4CompiledSourceRoot
   build: (candidates: string[]) => string
 }
 

package/src/v4/source-scan.ts

@@ -0,0 +1,432 @@
+import type { SourceEntry } from '@tailwindcss/oxide'
+import type { TailwindV4CompiledSourceRoot, TailwindV4SourcePattern } from './types'
+import { realpathSync } from 'node:fs'
+import { stat } from 'node:fs/promises'
+import process from 'node:process'
+import path from 'pathe'
+import micromatch from 'micromatch'
+
+export const TAILWIND_V4_IGNORED_CONTENT_DIRS = [
+  '.git',
+  '.hg',
+  '.jj',
+  '.next',
+  '.parcel-cache',
+  '.pnpm-store',
+  '.svelte-kit',
+  '.svn',
+  '.turbo',
+  '.venv',
+  '.vercel',
+  '.yarn',
+  '__pycache__',
+  'node_modules',
+  'venv',
+]
+
+export const TAILWIND_V4_IGNORED_EXTENSIONS = [
+  'less',
+  'lock',
+  'sass',
+  'scss',
+  'styl',
+  'log',
+]
+
+export const TAILWIND_V4_IGNORED_FILES = [
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'bun.lockb',
+  '.gitignore',
+  '.env',
+  '.env.*',
+]
+
+export const TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN = '**/*'
+
+function uniqueResolvedPaths(values: Iterable<string | undefined>) {
+  const result: string[] = []
+  for (const value of values) {
+    if (!value) {
+      continue
+    }
+    const resolved = path.resolve(value)
+    if (!result.includes(resolved)) {
+      result.push(resolved)
+    }
+  }
+  return result
+}
+
+export function toPosixPath(value: string) {
+  return value.replaceAll(path.sep, '/')
+}
+
+export function resolveSourceScanPath(value: string) {
+  const resolved = path.resolve(value)
+  try {
+    return realpathSync.native(resolved)
+  }
+  catch {
+    return resolved
+  }
+}
+
+export function normalizeGlobPattern(pattern: string) {
+  return pattern.startsWith('./') ? pattern.slice(2) : pattern
+}
+
+function hasGlobMagic(value: string) {
+  return /[*?[\]{}()!+@]/.test(value)
+}
+
+function splitStaticGlobPrefix(pattern: string) {
+  const normalized = normalizeGlobPattern(pattern)
+  const segments = normalized.split(/[\\/]+/)
+  const prefix: string[] = []
+  const rest: string[] = []
+  let reachedGlob = false
+
+  for (const segment of segments) {
+    if (!reachedGlob && segment && !hasGlobMagic(segment)) {
+      prefix.push(segment)
+      continue
+    }
+    reachedGlob = true
+    rest.push(segment)
+  }
+
+  return {
+    prefix,
+    rest,
+  }
+}
+
+async function pathExistsAsDirectory(file: string) {
+  try {
+    return (await stat(file)).isDirectory()
+  }
+  catch {
+    return false
+  }
+}
+
+export function createTailwindV4DefaultIgnoreSources(base: string): TailwindV4SourcePattern[] {
+  return [
+    ...TAILWIND_V4_IGNORED_CONTENT_DIRS.map(pattern => ({
+      base,
+      pattern: `**/${pattern}/**`,
+      negated: true,
+    })),
+    ...TAILWIND_V4_IGNORED_EXTENSIONS.map(extension => ({
+      base,
+      pattern: `**/*.${extension}`,
+      negated: true,
+    })),
+    ...TAILWIND_V4_IGNORED_FILES.map(pattern => ({
+      base,
+      pattern: `**/${pattern}`,
+      negated: true,
+    })),
+  ]
+}
+
+export function createTailwindV4RootSources(
+  root: TailwindV4CompiledSourceRoot,
+  fallbackBase: string,
+): TailwindV4SourcePattern[] {
+  if (root === 'none') {
+    return []
+  }
+  if (root === null) {
+    return [{ base: fallbackBase, pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN, negated: false }]
+  }
+  return [{ ...root, negated: false }]
+}
+
+export function createTailwindV4CompiledSourceEntries(
+  root: TailwindV4CompiledSourceRoot,
+  sources: TailwindV4SourcePattern[],
+  fallbackBase: string,
+) {
+  return [
+    ...createTailwindV4RootSources(root, fallbackBase),
+    ...sources,
+  ]
+}
+
+export async function resolveTailwindV4SourceEntry(
+  sourcePath: string,
+  base: string,
+  negated: boolean,
+  defaultPattern = TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+): Promise<TailwindV4SourcePattern> {
+  const absoluteSource = path.isAbsolute(sourcePath) ? path.resolve(sourcePath) : path.resolve(base, sourcePath)
+
+  if (await pathExistsAsDirectory(absoluteSource)) {
+    return {
+      base: absoluteSource,
+      negated,
+      pattern: normalizeGlobPattern(defaultPattern),
+    }
+  }
+
+  if (path.isAbsolute(sourcePath)) {
+    return {
+      base: path.dirname(absoluteSource),
+      negated,
+      pattern: normalizeGlobPattern(path.basename(absoluteSource)),
+    }
+  }
+
+  const { prefix, rest } = splitStaticGlobPrefix(sourcePath)
+  if (prefix.length > 0 && rest.length > 0) {
+    return {
+      base: path.resolve(base, ...prefix),
+      negated,
+      pattern: normalizeGlobPattern(rest.join('/')),
+    }
+  }
+
+  return {
+    base,
+    negated,
+    pattern: normalizeGlobPattern(sourcePath),
+  }
+}
+
+export async function normalizeTailwindV4SourceEntries(
+  sources: TailwindV4SourcePattern[],
+  options: {
+    cwd?: string
+    defaultPattern?: string
+  } = {},
+) {
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd()
+  return Promise.all(sources.map(source =>
+    resolveTailwindV4SourceEntry(
+      source.pattern,
+      source.base ? path.resolve(source.base) : cwd,
+      source.negated,
+      options.defaultPattern,
+    )))
+}
+
+function expandBracePattern(pattern: string): string[] {
+  const index = pattern.indexOf('{')
+  if (index === -1) {
+    return [pattern]
+  }
+
+  const rest = pattern.slice(index)
+  let depth = 0
+  let endIndex = -1
+  for (let i = 0; i < rest.length; i++) {
+    const char = rest[i]
+    if (char === '\\') {
+      i += 1
+      continue
+    }
+    if (char === '{') {
+      depth += 1
+      continue
+    }
+    if (char === '}') {
+      depth -= 1
+      if (depth === 0) {
+        endIndex = i
+        break
+      }
+    }
+  }
+  if (endIndex === -1) {
+    return [pattern]
+  }
+
+  const prefix = pattern.slice(0, index)
+  const inner = rest.slice(1, endIndex)
+  const suffix = rest.slice(endIndex + 1)
+  const parts: string[] = []
+  const stack: string[] = []
+  let lastPos = 0
+  for (let i = 0; i < inner.length; i++) {
+    const char = inner[i]
+    if (char === '\\') {
+      i += 1
+      continue
+    }
+    if (char === '{') {
+      stack.push('}')
+      continue
+    }
+    if (char === '}' && stack[stack.length - 1] === '}') {
+      stack.pop()
+      continue
+    }
+    if (char === ',' && stack.length === 0) {
+      parts.push(inner.slice(lastPos, i))
+      lastPos = i + 1
+    }
+  }
+  parts.push(inner.slice(lastPos))
+
+  return parts.flatMap(part =>
+    expandBracePattern(`${prefix}${part}${suffix}`))
+}
+
+export function expandTailwindV4SourceEntryBraces(sources: TailwindV4SourcePattern[]): TailwindV4SourcePattern[] {
+  return sources.flatMap((source) => {
+    const base = path.resolve(source.base)
+    return expandBracePattern(source.pattern).map(pattern => ({
+      base,
+      pattern,
+      negated: source.negated,
+    }))
+  })
+}
+
+export function normalizeTailwindV4ScannerSources(
+  sources: TailwindV4SourcePattern[] | undefined,
+  cwd: string,
+  ignoredSources: TailwindV4SourcePattern[] = [],
+): SourceEntry[] {
+  const baseSources = sources?.length
+    ? sources
+    : [
+        {
+          base: cwd,
+          pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+          negated: false,
+        },
+      ]
+
+  return expandTailwindV4SourceEntryBraces([...baseSources, ...ignoredSources])
+}
+
+function normalizeEntryPattern(entry: TailwindV4SourcePattern) {
+  return path.isAbsolute(entry.pattern)
+    ? toPosixPath(path.relative(resolveSourceScanPath(entry.base), entry.pattern))
+    : normalizeGlobPattern(entry.pattern)
+}
+
+function isFileMatchedByTailwindV4SourceEntry(file: string, entry: TailwindV4SourcePattern) {
+  const relative = toPosixPath(path.relative(resolveSourceScanPath(entry.base), file))
+  return Boolean(relative)
+    && !relative.startsWith('../')
+    && !path.isAbsolute(relative)
+    && micromatch.isMatch(relative, normalizeEntryPattern(entry))
+}
+
+export function isFileExcludedByTailwindV4SourceEntries(
+  file: string,
+  entries: TailwindV4SourcePattern[] | undefined,
+) {
+  if (!entries?.length) {
+    return false
+  }
+  const resolvedFile = resolveSourceScanPath(file)
+  return entries.some(entry => entry.negated && isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry))
+}
+
+export function isFileMatchedByTailwindV4SourceEntries(
+  file: string,
+  entries: TailwindV4SourcePattern[] | undefined,
+) {
+  if (!entries?.length) {
+    return true
+  }
+
+  const positiveEntries = entries.filter(entry => !entry.negated)
+  const negativeEntries = entries.filter(entry => entry.negated)
+  if (positiveEntries.length === 0) {
+    return false
+  }
+
+  const resolvedFile = resolveSourceScanPath(file)
+  const matchesPositive = positiveEntries.some(entry => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry))
+  if (!matchesPositive) {
+    return false
+  }
+
+  return !negativeEntries.some(entry => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry))
+}
+
+export function createTailwindV4SourceEntryMatcher(entries: TailwindV4SourcePattern[] | undefined) {
+  if (!entries?.length) {
+    return undefined
+  }
+  return (file: string) => isFileMatchedByTailwindV4SourceEntries(file, entries)
+}
+
+export function createTailwindV4SourceExclusionMatcher(entries: TailwindV4SourcePattern[] | undefined) {
+  if (!entries?.length) {
+    return undefined
+  }
+  return (file: string) => isFileExcludedByTailwindV4SourceEntries(file, entries)
+}
+
+export function groupTailwindV4SourceEntriesByBase(entries: TailwindV4SourcePattern[]) {
+  const entriesByBase = new Map<string, TailwindV4SourcePattern[]>()
+  for (const entry of entries) {
+    const base = path.resolve(entry.base)
+    const group = entriesByBase.get(base) ?? []
+    group.push({
+      ...entry,
+      base,
+      pattern: normalizeGlobPattern(entry.pattern),
+    })
+    entriesByBase.set(base, group)
+  }
+  return entriesByBase
+}
+
+export async function expandTailwindV4SourceEntries(
+  entries: TailwindV4SourcePattern[],
+  resolveFiles: (options: { cwd: string, sources: TailwindV4SourcePattern[] }) => Promise<string[]>,
+) {
+  if (entries.length === 0) {
+    return []
+  }
+
+  const files = new Set<string>()
+  await Promise.all([...groupTailwindV4SourceEntriesByBase(entries).entries()].map(async ([base, group]) => {
+    const matched = await resolveFiles({
+      cwd: base,
+      sources: group,
+    })
+    for (const file of matched) {
+      files.add(path.resolve(file))
+    }
+  }))
+
+  return [...files].filter(file => !isFileExcludedByTailwindV4SourceEntries(file, entries))
+}
+
+export function mergeTailwindV4SourceEntries(...entries: Array<TailwindV4SourcePattern[] | undefined>) {
+  const result: TailwindV4SourcePattern[] = []
+  const seen = new Set<string>()
+  for (const group of entries) {
+    for (const entry of group ?? []) {
+      const normalized = {
+        base: path.resolve(entry.base),
+        pattern: normalizeGlobPattern(entry.pattern),
+        negated: entry.negated,
+      }
+      const key = JSON.stringify(normalized)
+      if (seen.has(key)) {
+        continue
+      }
+      seen.add(key)
+      result.push(normalized)
+    }
+  }
+  return result
+}
+
+export function resolveTailwindV4SourceBaseCandidates(
+  projectRoot: string,
+  base: string,
+  baseFallbacks: string[],
+) {
+  return uniqueResolvedPaths([base, projectRoot, ...baseFallbacks])
+}