tailwindcss-patch 9.0.0-alpha.1 → 9.0.0-alpha.2

package/src/extraction/candidate-extractor.ts

@@ -0,0 +1,354 @@
+import type { SourceEntry } from '@tailwindcss/oxide'
+import type {
+  TailwindTokenByFileMap,
+  TailwindTokenFileKey,
+  TailwindTokenLocation,
+  TailwindTokenReport,
+} from '../types'
+import { promises as fs } from 'node:fs'
+import process from 'node:process'
+import path from 'pathe'
+
+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
+  baseFallbacks?: string[]
+  css?: string
+  cwd?: string
+}
+
+export async function extractRawCandidatesWithPositions(
+  content: string,
+  extension: string = 'html',
+): Promise<{ rawCandidate: string, start: number, end: number }[]> {
+  const { Scanner } = await getOxideModule()
+  const scanner = new Scanner({})
+  const result = scanner.getCandidatesWithPositions({ content, extension })
+
+  return result.map(({ candidate, position }) => ({
+    rawCandidate: candidate,
+    start: position,
+    end: position + candidate.length,
+  }))
+}
+
+export async function extractRawCandidates(
+  sources?: SourceEntry[],
+): Promise<string[]> {
+  const { Scanner } = await getOxideModule()
+  const scanner = new Scanner(sources === undefined ? {} : { sources })
+
+  return scanner.scan()
+}
+
+export async function extractValidCandidates(options?: ExtractValidCandidatesOption) {
+  const providedOptions = options ?? {}
+  const defaultCwd = providedOptions.cwd ?? process.cwd()
+
+  const base = providedOptions.base ?? defaultCwd
+  const baseFallbacks = providedOptions.baseFallbacks ?? []
+  const css = providedOptions.css ?? '@import "tailwindcss";'
+  const sources = (providedOptions.sources ?? [
+    {
+      base: defaultCwd,
+      pattern: '**/*',
+      negated: false,
+    },
+  ]).map(source => ({
+    base: source.base ?? defaultCwd,
+    pattern: source.pattern,
+    negated: source.negated,
+  }))
+
+  const designSystemKey = createDesignSystemCacheKey(css, [base, ...baseFallbacks])
+  const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks])
+  const candidateCache = designSystemCandidateCache.get(designSystemKey) ?? new Map<string, boolean>()
+  designSystemCandidateCache.set(designSystemKey, candidateCache)
+
+  const candidates = await extractRawCandidates(sources)
+  const validCandidates: string[] = []
+  const uncachedCandidates: string[] = []
+
+  for (const rawCandidate of candidates) {
+    const cached = candidateCache.get(rawCandidate)
+    if (cached === true) {
+      validCandidates.push(rawCandidate)
+      continue
+    }
+
+    if (cached === false) {
+      continue
+    }
+
+    if (designSystem.parseCandidate(rawCandidate).length > 0) {
+      uncachedCandidates.push(rawCandidate)
+      continue
+    }
+
+    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 === undefined) {
+      continue
+    }
+    const candidateCss = cssByCandidate[index]
+    const isValid = typeof candidateCss === 'string' && candidateCss.trim().length > 0
+    candidateCache.set(candidate, isValid)
+    if (!isValid) {
+      continue
+    }
+    validCandidates.push(candidate)
+  }
+
+  return validCandidates
+}
+
+function normalizeSources(sources: SourceEntry[] | undefined, cwd: string) {
+  const baseSources = sources?.length
+    ? sources
+    : [
+        {
+          base: cwd,
+          pattern: '**/*',
+          negated: false,
+        },
+      ]
+
+  return baseSources.map(source => ({
+    base: source.base ?? cwd,
+    pattern: source.pattern,
+    negated: source.negated,
+  }))
+}
+
+function buildLineOffsets(content: string) {
+  const offsets: number[] = [0]
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === '\n') {
+      offsets.push(i + 1)
+    }
+  }
+  // Push a sentinel to simplify bounds checks during binary search.
+  if (offsets[offsets.length - 1] !== content.length) {
+    offsets.push(content.length)
+  }
+  return offsets
+}
+
+function resolveLineMeta(content: string, offsets: number[], index: number) {
+  let low = 0
+  let high = offsets.length - 1
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2)
+    const start = offsets[mid]
+    if (start === undefined) {
+      break
+    }
+    const nextStart = offsets[mid + 1] ?? content.length
+
+    if (index < start) {
+      high = mid - 1
+      continue
+    }
+
+    if (index >= nextStart) {
+      low = mid + 1
+      continue
+    }
+
+    const line = mid + 1
+    const column = index - start + 1
+    const lineEnd = content.indexOf('\n', start)
+    const lineText = content.slice(start, lineEnd === -1 ? content.length : lineEnd)
+
+    return { line, column, lineText }
+  }
+
+  const lastStart = offsets[offsets.length - 2] ?? 0
+  return {
+    line: offsets.length - 1,
+    column: index - lastStart + 1,
+    lineText: content.slice(lastStart),
+  }
+}
+
+function toExtension(filename: string) {
+  const ext = path.extname(filename).replace(/^\./, '')
+  return ext || 'txt'
+}
+
+function toRelativeFile(cwd: string, filename: string) {
+  const relative = path.relative(cwd, filename)
+  return relative === '' ? path.basename(filename) : relative
+}
+
+export interface ExtractProjectCandidatesOptions {
+  cwd?: string
+  sources?: SourceEntry[]
+}
+
+export async function extractProjectCandidatesWithPositions(
+  options?: ExtractProjectCandidatesOptions,
+): Promise<TailwindTokenReport> {
+  const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd()
+  const normalizedSources = normalizeSources(options?.sources, cwd)
+  const { Scanner } = await getOxideModule()
+  const scanner = new Scanner({
+    sources: normalizedSources,
+  })
+
+  const files = scanner.files ?? []
+  const entries: TailwindTokenLocation[] = []
+  const skipped: TailwindTokenReport['skippedFiles'] = []
+
+  for (const file of files) {
+    let content: string
+    try {
+      content = await fs.readFile(file, 'utf8')
+    }
+    catch (error) {
+      skipped.push({
+        file,
+        reason: error instanceof Error ? error.message : 'Unknown error',
+      })
+      continue
+    }
+
+    const extension = toExtension(file)
+    const matches = scanner.getCandidatesWithPositions({
+      file,
+      content,
+      extension,
+    })
+
+    if (!matches.length) {
+      continue
+    }
+
+    const offsets = buildLineOffsets(content)
+    const relativeFile = toRelativeFile(cwd, file)
+
+    for (const match of matches) {
+      const info = resolveLineMeta(content, offsets, match.position)
+      entries.push({
+        rawCandidate: match.candidate,
+        file,
+        relativeFile,
+        extension,
+        start: match.position,
+        end: match.position + match.candidate.length,
+        length: match.candidate.length,
+        line: info.line,
+        column: info.column,
+        lineText: info.lineText,
+      })
+    }
+  }
+
+  return {
+    entries,
+    filesScanned: files.length,
+    skippedFiles: skipped,
+    sources: normalizedSources,
+  }
+}
+
+export function groupTokensByFile(
+  report: TailwindTokenReport,
+  options?: { key?: TailwindTokenFileKey, stripAbsolutePaths?: boolean },
+): TailwindTokenByFileMap {
+  const key = options?.key ?? 'relative'
+  const stripAbsolute = options?.stripAbsolutePaths ?? key !== 'absolute'
+
+  return report.entries.reduce<TailwindTokenByFileMap>((acc, entry) => {
+    const bucketKey = key === 'absolute' ? entry.file : entry.relativeFile
+    const bucket = acc[bucketKey] ?? (acc[bucketKey] = [])
+    const value = stripAbsolute
+      ? {
+          ...entry,
+          file: entry.relativeFile,
+        }
+      : entry
+    bucket.push(value)
+    return acc
+  }, {})
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+import type { TailwindcssMangleConfig } from '@tailwindcss-mangle/config'
+
+export { TailwindcssPatcher } from './api/tailwindcss-patcher'
+export { CacheStore } from './cache/store'
+export {
+  createTailwindcssPatchCli,
+  mountTailwindcssPatchCommands,
+  type TailwindcssPatchCliMountOptions,
+  type TailwindcssPatchCliOptions,
+  type TailwindcssPatchCommand,
+  type TailwindcssPatchCommandContext,
+  type TailwindcssPatchCommandHandler,
+  type TailwindcssPatchCommandHandlerMap,
+  type TailwindcssPatchCommandOptionDefinition,
+  type TailwindcssPatchCommandOptions,
+  tailwindcssPatchCommands,
+  VALIDATE_EXIT_CODES,
+  VALIDATE_FAILURE_REASONS,
+  ValidateCommandError,
+  type ValidateFailureReason,
+  type ValidateFailureSummary,
+  type ValidateJsonFailurePayload,
+  type ValidateJsonSuccessPayload,
+} from './commands/cli'
+export {
+  type ConfigFileMigrationEntry,
+  type ConfigFileMigrationReport,
+  migrateConfigFiles,
+  type MigrateConfigFilesOptions,
+  MIGRATION_REPORT_KIND,
+  MIGRATION_REPORT_SCHEMA_VERSION,
+  restoreConfigFiles,
+  type RestoreConfigFilesOptions,
+  type RestoreConfigFilesResult,
+} from './commands/migrate-config'
+export { normalizeOptions } from './config'
+export type { TailwindCssPatchOptions } from './config'
+export {
+  extractProjectCandidatesWithPositions,
+  extractRawCandidates,
+  extractRawCandidatesWithPositions,
+  extractValidCandidates,
+  groupTokensByFile,
+} from './extraction/candidate-extractor'
+export {
+  collectClassesFromContexts,
+  collectClassesFromTailwindV4,
+  getPatchStatusReport,
+  loadRuntimeContexts,
+  runTailwindBuild,
+} from './install'
+export { default as logger } from './logger'
+export * from './types'
+
+export function defineConfig<T extends TailwindcssMangleConfig>(config: T): T {
+  return config
+}

package/src/install/class-collector.ts

@@ -0,0 +1 @@
+export { collectClassesFromContexts, collectClassesFromTailwindV4 } from '../runtime/class-collector'

package/src/install/context-registry.ts

@@ -0,0 +1 @@
+export { loadRuntimeContexts } from '../runtime/context-registry'

package/src/install/index.ts

@@ -0,0 +1,5 @@
+export { collectClassesFromContexts, collectClassesFromTailwindV4 } from './class-collector'
+export { loadRuntimeContexts } from './context-registry'
+export { applyTailwindPatches } from './patch-runner'
+export { runTailwindBuild } from './process-tailwindcss'
+export { getPatchStatusReport } from './status'

package/src/install/patch-runner.ts

@@ -0,0 +1 @@
+export { applyTailwindPatches } from '../patching/patch-runner'

package/src/install/process-tailwindcss.ts

@@ -0,0 +1 @@
+export { runTailwindBuild } from '../runtime/process-tailwindcss'

package/src/install/status.ts

@@ -0,0 +1 @@
+export { getPatchStatusReport } from '../patching/status'

package/src/logger.ts

@@ -0,0 +1,5 @@
+import { createConsola } from 'consola'
+
+const logger = createConsola()
+
+export default logger

package/src/options/legacy.ts

@@ -0,0 +1,93 @@
+import type { RegistryOptions } from '@tailwindcss-mangle/config'
+import type { TailwindCssPatchOptions } from './types'
+
+const deprecatedRegistryMapping = {
+  output: 'extract',
+  tailwind: 'tailwindcss',
+} as const
+
+type DeprecatedRegistryKey = keyof typeof deprecatedRegistryMapping
+
+const deprecatedTailwindMapping = {
+  package: 'packageName',
+  legacy: 'v2',
+  classic: 'v3',
+  next: 'v4',
+} as const
+
+type DeprecatedTailwindKey = keyof typeof deprecatedTailwindMapping
+
+function assertNoDeprecatedRegistryOptions(registry: RegistryOptions) {
+  const usedRegistryKeys = (Object.keys(deprecatedRegistryMapping) as DeprecatedRegistryKey[])
+    .filter(key => Object.prototype.hasOwnProperty.call(registry, key))
+
+  if (usedRegistryKeys.length > 0) {
+    const mapping = usedRegistryKeys.map(key => `${key} -> ${deprecatedRegistryMapping[key]}`).join(', ')
+    throw new Error(
+      `Legacy registry fields are no longer supported: ${usedRegistryKeys.join(', ')}. Use the modern fields instead: ${mapping}.`,
+    )
+  }
+
+  const tailwind = registry.tailwindcss
+  if (!tailwind) {
+    return
+  }
+
+  const usedTailwindKeys = (Object.keys(deprecatedTailwindMapping) as DeprecatedTailwindKey[])
+    .filter(key => Object.prototype.hasOwnProperty.call(tailwind, key))
+
+  if (usedTailwindKeys.length > 0) {
+    const mapping = usedTailwindKeys.map(key => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(', ')
+    throw new Error(
+      `Legacy "registry.tailwindcss" fields are no longer supported: ${usedTailwindKeys.join(', ')}. Use the modern fields instead: ${mapping}.`,
+    )
+  }
+}
+
+export function fromUnifiedConfig(registry?: RegistryOptions): TailwindCssPatchOptions {
+  if (!registry) {
+    return {}
+  }
+
+  assertNoDeprecatedRegistryOptions(registry)
+
+  const extract = registry.extract
+    ? {
+        ...(registry.extract.write === undefined ? {} : { write: registry.extract.write }),
+        ...(registry.extract.file === undefined ? {} : { file: registry.extract.file }),
+        ...(registry.extract.format === undefined ? {} : { format: registry.extract.format }),
+        ...(registry.extract.pretty === undefined ? {} : { pretty: registry.extract.pretty }),
+        ...(registry.extract.removeUniversalSelector === undefined ? {} : { removeUniversalSelector: registry.extract.removeUniversalSelector }),
+      }
+    : undefined
+
+  const tailwindcss = registry.tailwindcss
+    ? {
+        ...(registry.tailwindcss.version === undefined ? {} : { version: registry.tailwindcss.version }),
+        ...(registry.tailwindcss.packageName === undefined ? {} : { packageName: registry.tailwindcss.packageName }),
+        ...(registry.tailwindcss.resolve === undefined ? {} : { resolve: registry.tailwindcss.resolve }),
+        ...(registry.tailwindcss.config === undefined ? {} : { config: registry.tailwindcss.config }),
+        ...(registry.tailwindcss.cwd === undefined ? {} : { cwd: registry.tailwindcss.cwd }),
+        ...(registry.tailwindcss.v2 === undefined ? {} : { v2: registry.tailwindcss.v2 }),
+        ...(registry.tailwindcss.v3 === undefined ? {} : { v3: registry.tailwindcss.v3 }),
+        ...(registry.tailwindcss.v4 === undefined ? {} : { v4: registry.tailwindcss.v4 }),
+      }
+    : undefined
+
+  const apply = registry.apply
+    ? {
+        ...(registry.apply.overwrite === undefined ? {} : { overwrite: registry.apply.overwrite }),
+        ...(registry.apply.exposeContext === undefined ? {} : { exposeContext: registry.apply.exposeContext }),
+        ...(registry.apply.extendLengthUnits === undefined ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }),
+      }
+    : undefined
+
+  return {
+    ...(registry.projectRoot === undefined ? {} : { projectRoot: registry.projectRoot }),
+    ...(apply === undefined ? {} : { apply }),
+    ...(registry.cache === undefined ? {} : { cache: registry.cache }),
+    ...(registry.filter === undefined ? {} : { filter: registry.filter }),
+    ...(extract === undefined ? {} : { extract }),
+    ...(tailwindcss === undefined ? {} : { tailwindcss }),
+  }
+}