tailwindcss-patch 9.4.3 → 9.5.0

package/src/v4/source-scan.ts

@@ -1,432 +0,0 @@
-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 micromatch from 'micromatch'
-import path from 'pathe'
-
-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])
-}

package/src/v4/source.ts

@@ -1,235 +0,0 @@
-import type { NormalizedTailwindCssPatchOptions, TailwindCssPatchOptions } from '../config'
-import type { TailwindV4CssSource, TailwindV4ResolvedSource, TailwindV4SourceOptions } from './types'
-import { promises as fs } from 'node:fs'
-import process from 'node:process'
-import path from 'pathe'
-import { normalizeOptions } from '../config'
-
-function resolveBase(value: string | undefined, fallback: string) {
-  return value === undefined
-    ? fallback
-    : path.isAbsolute(value)
-      ? path.resolve(value)
-      : path.resolve(fallback, value)
-}
-
-function uniquePaths(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
-}
-
-function toCssImportPath(value: string) {
-  return value.replaceAll('\\', '/')
-}
-
-function quoteCssImport(value: string) {
-  return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')
-}
-
-function isPostcssPluginSpecifier(packageName: string) {
-  return packageName === '@tailwindcss/postcss'
-    || /(?:^|[/\\])@tailwindcss[/\\]postcss(?:[/\\]|$)/.test(packageName)
-    || /(?:^|[/\\])postcss(?:[/\\]|$)/i.test(packageName)
-    || /postcss\.config\.[cm]?[jt]s$/i.test(packageName)
-}
-
-function createDefaultCss(packageName: string | undefined) {
-  const cssPackageName = packageName && !isPostcssPluginSpecifier(packageName)
-    ? packageName
-    : 'tailwindcss'
-  return `@import "${quoteCssImport(toCssImportPath(cssPackageName))}";`
-}
-
-async function pathExists(filePath: string) {
-  try {
-    await fs.access(filePath)
-    return true
-  }
-  catch {
-    return false
-  }
-}
-
-async function resolveCssEntries(entries: string[], projectRoot: string, base: string | undefined) {
-  const resolvedEntries = entries.map(entry => ({
-    original: entry,
-    absolute: path.isAbsolute(entry) ? path.resolve(entry) : path.resolve(projectRoot, entry),
-  }))
-  const resolvedBase = base ?? path.dirname(resolvedEntries[0]?.absolute ?? projectRoot)
-  const dependencies = resolvedEntries.map(entry => entry.absolute)
-  const cssParts: string[] = []
-
-  for (const entry of resolvedEntries) {
-    if (await pathExists(entry.absolute)) {
-      cssParts.push(await fs.readFile(entry.absolute, 'utf8'))
-      continue
-    }
-
-    const importPath = path.isAbsolute(entry.original)
-      ? entry.absolute
-      : path.relative(resolvedBase, entry.absolute)
-    cssParts.push(`@import "${quoteCssImport(toCssImportPath(importPath))}";`)
-  }
-
-  return {
-    base: resolvedBase,
-    css: cssParts.join('\n'),
-    dependencies,
-  }
-}
-
-function resolveCssSources(sources: TailwindV4CssSource[], projectRoot: string, base: string | undefined) {
-  const resolvedSources = sources.map(source => ({
-    ...source,
-    base: source.base === undefined ? undefined : resolveBase(source.base, projectRoot),
-    file: source.file === undefined
-      ? undefined
-      : path.isAbsolute(source.file)
-        ? path.resolve(source.file)
-        : path.resolve(projectRoot, source.file),
-    dependencies: source.dependencies?.map(dependency =>
-      path.isAbsolute(dependency) ? path.resolve(dependency) : path.resolve(projectRoot, dependency),
-    ) ?? [],
-  }))
-  const firstSource = resolvedSources[0]
-  const resolvedBase = base
-    ?? firstSource?.base
-    ?? (firstSource?.file ? path.dirname(firstSource.file) : projectRoot)
-  const dependencies = resolvedSources.flatMap(source => [
-    source.file,
-    ...source.dependencies,
-  ]).filter((dependency): dependency is string => Boolean(dependency))
-
-  return {
-    base: resolvedBase,
-    css: resolvedSources.map(source => source.css).join('\n'),
-    dependencies,
-  }
-}
-
-function normalizeResolvedSource(
-  source: {
-    projectRoot: string
-    cwd: string
-    base: string
-    baseFallbacks: string[]
-    css: string
-    dependencies: string[]
-  },
-): TailwindV4ResolvedSource {
-  const baseFallbacks = uniquePaths([
-    ...source.baseFallbacks,
-    source.projectRoot,
-    source.cwd,
-  ]).filter(base => base !== source.base)
-
-  return {
-    projectRoot: source.projectRoot,
-    base: source.base,
-    baseFallbacks,
-    css: source.css,
-    dependencies: Array.from(new Set(source.dependencies.map(dependency => path.resolve(dependency)))),
-  }
-}
-
-export async function resolveTailwindV4Source(options: TailwindV4SourceOptions = {}): Promise<TailwindV4ResolvedSource> {
-  const projectRoot = resolveBase(options.projectRoot, process.cwd())
-  const cwd = resolveBase(options.cwd, projectRoot)
-  const configuredBase = options.base === undefined ? undefined : resolveBase(options.base, projectRoot)
-  const baseFallbacks = uniquePaths(options.baseFallbacks?.map(base => resolveBase(base, projectRoot)) ?? [])
-
-  if (options.css !== undefined) {
-    return normalizeResolvedSource({
-      projectRoot,
-      cwd,
-      base: configuredBase ?? cwd,
-      baseFallbacks,
-      css: options.css,
-      dependencies: [],
-    })
-  }
-
-  if (options.cssEntries?.length || options.cssSources?.length) {
-    const entries = options.cssEntries?.length
-      ? await resolveCssEntries(options.cssEntries, projectRoot, configuredBase)
-      : undefined
-    const sources = options.cssSources?.length
-      ? resolveCssSources(options.cssSources, projectRoot, configuredBase)
-      : undefined
-    const css = [
-      entries?.css,
-      sources?.css,
-    ].filter(Boolean).join('\n')
-    return normalizeResolvedSource({
-      projectRoot,
-      cwd,
-      base: configuredBase ?? entries?.base ?? sources?.base ?? cwd,
-      baseFallbacks,
-      css,
-      dependencies: [
-        ...(entries?.dependencies ?? []),
-        ...(sources?.dependencies ?? []),
-      ],
-    })
-  }
-
-  return normalizeResolvedSource({
-    projectRoot,
-    cwd,
-    base: configuredBase ?? cwd,
-    baseFallbacks,
-    css: createDefaultCss(options.packageName),
-    dependencies: [],
-  })
-}
-
-function resolveConfigDir(config: string | undefined, projectRoot: string) {
-  if (!config) {
-    return undefined
-  }
-  const configPath = path.isAbsolute(config) ? config : path.resolve(projectRoot, config)
-  return path.dirname(configPath)
-}
-
-function createSourceOptionsFromNormalizedPatchOptions(
-  options: NormalizedTailwindCssPatchOptions,
-): TailwindV4SourceOptions {
-  const v4 = options.tailwind.v4
-  const configDir = resolveConfigDir(options.tailwind.config, options.projectRoot)
-  const baseFallbacks = uniquePaths([
-    v4?.configuredBase,
-    options.tailwind.cwd,
-    options.projectRoot,
-    configDir,
-  ])
-
-  return {
-    projectRoot: options.projectRoot,
-    ...(options.tailwind.cwd === undefined ? {} : { cwd: options.tailwind.cwd }),
-    ...(v4?.configuredBase === undefined ? {} : { base: v4.configuredBase }),
-    baseFallbacks,
-    ...(v4?.css === undefined ? {} : { css: v4.css }),
-    ...(v4?.cssSources === undefined ? {} : { cssSources: v4.cssSources }),
-    ...(v4?.cssEntries === undefined ? {} : { cssEntries: v4.cssEntries }),
-    packageName: options.tailwind.packageName,
-  }
-}
-
-export function tailwindV4SourceOptionsFromPatchOptions(options: TailwindCssPatchOptions): TailwindV4SourceOptions {
-  return createSourceOptionsFromNormalizedPatchOptions(normalizeOptions(options))
-}
-
-export async function resolveTailwindV4SourceFromPatchOptions(
-  options: TailwindCssPatchOptions,
-): Promise<TailwindV4ResolvedSource> {
-  return resolveTailwindV4Source(tailwindV4SourceOptionsFromPatchOptions(options))
-}

package/src/v4/style-generator.ts

@@ -1,44 +0,0 @@
-import type {
-  TailwindV4SourceOptions,
-  TailwindV4StyleGenerateOptions,
-  TailwindV4StyleGenerateResult,
-} from './types'
-import { collectTailwindStyleCandidates } from '../style-candidates'
-import { createTailwindV4Engine } from './engine'
-import { resolveTailwindV4Source } from './source'
-
-function createSourceOptions(options: TailwindV4StyleGenerateOptions): TailwindV4SourceOptions {
-  return {
-    ...(options.projectRoot === undefined ? {} : { projectRoot: options.projectRoot }),
-    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
-    ...(options.base === undefined ? {} : { base: options.base }),
-    ...(options.baseFallbacks === undefined ? {} : { baseFallbacks: options.baseFallbacks }),
-    ...(options.css === undefined ? {} : { css: options.css }),
-    ...(options.cssSources === undefined ? {} : { cssSources: options.cssSources }),
-    ...(options.cssEntries === undefined ? {} : { cssEntries: options.cssEntries }),
-    ...(options.packageName === undefined ? {} : { packageName: options.packageName }),
-  }
-}
-
-export async function collectTailwindV4StyleCandidates(
-  options: Pick<TailwindV4StyleGenerateOptions, 'bareArbitraryValues' | 'candidates' | 'sources'>,
-): Promise<Set<string>> {
-  return collectTailwindStyleCandidates(options)
-}
-
-export async function generateTailwindV4Style(
-  options: TailwindV4StyleGenerateOptions = {},
-): Promise<TailwindV4StyleGenerateResult> {
-  const source = options.source ?? await resolveTailwindV4Source(createSourceOptions(options))
-  const candidates = await collectTailwindV4StyleCandidates(options)
-  const result = await createTailwindV4Engine(source).generate({
-    candidates,
-    ...(options.bareArbitraryValues === undefined ? {} : { bareArbitraryValues: options.bareArbitraryValues }),
-    ...(options.scanSources === undefined ? {} : { scanSources: options.scanSources }),
-  })
-  return {
-    ...result,
-    tokens: result.rawCandidates,
-    source,
-  }
-}