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

package/src/commands/token-output.ts

@@ -0,0 +1,30 @@
+import type { TailwindTokenByFileMap, TailwindTokenLocation } from '../types'
+
+export type TokenOutputFormat = 'json' | 'lines' | 'grouped-json'
+export type TokenGroupKey = 'relative' | 'absolute'
+
+export const TOKEN_FORMATS: TokenOutputFormat[] = ['json', 'lines', 'grouped-json']
+export const DEFAULT_TOKEN_REPORT = '.tw-patch/tw-token-report.json'
+
+export function formatTokenLine(entry: TailwindTokenLocation) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`
+}
+
+export function formatGroupedPreview(map: TailwindTokenByFileMap, limit: number = 3) {
+  const files = Object.keys(map)
+  if (!files.length) {
+    return { preview: '', moreFiles: 0 }
+  }
+
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file] ?? []
+    const sample = tokens.slice(0, 3).map(token => token.rawCandidate).join(', ')
+    const suffix = tokens.length > 3 ? ', …' : ''
+    return `${file}: ${tokens.length} tokens (${sample}${suffix})`
+  })
+
+  return {
+    preview: lines.join('\n'),
+    moreFiles: Math.max(0, files.length - limit),
+  }
+}

package/src/commands/types.ts

@@ -0,0 +1,137 @@
+import type { CAC, Command } from 'cac'
+import type { TailwindcssConfigResult } from '../config/workspace'
+import type logger from '../logger'
+import type {
+  ExtractResult,
+  PatchStatusReport,
+  TailwindCssPatchOptions,
+  TailwindTokenReport,
+} from '../types'
+import type { ConfigFileMigrationReport, RestoreConfigFilesResult } from './migration-types'
+import type { TokenGroupKey, TokenOutputFormat } from './token-output'
+
+export type TailwindcssPatchCommand = 'install' | 'extract' | 'tokens' | 'init' | 'migrate' | 'restore' | 'validate' | 'status'
+
+export const tailwindcssPatchCommands: TailwindcssPatchCommand[] = ['install', 'extract', 'tokens', 'init', 'migrate', 'restore', 'validate', 'status']
+
+type CacOptionConfig = Parameters<Command['option']>[2]
+
+export interface TailwindcssPatchCommandOptionDefinition {
+  flags: string
+  description?: string
+  config?: CacOptionConfig
+}
+
+export interface TailwindcssPatchCommandOptions {
+  name?: string
+  aliases?: string[]
+  description?: string
+  optionDefs?: TailwindcssPatchCommandOptionDefinition[]
+  appendDefaultOptions?: boolean
+}
+
+interface BaseCommandArgs {
+  cwd: string
+}
+
+interface InstallCommandArgs extends BaseCommandArgs {}
+interface ExtractCommandArgs extends BaseCommandArgs {
+  output?: string
+  format?: 'json' | 'lines'
+  css?: string
+  write?: boolean
+}
+interface TokensCommandArgs extends BaseCommandArgs {
+  output?: string
+  format?: TokenOutputFormat
+  groupKey?: TokenGroupKey
+  write?: boolean
+}
+interface InitCommandArgs extends BaseCommandArgs {}
+interface MigrateCommandArgs extends BaseCommandArgs {
+  config?: string
+  dryRun?: boolean
+  workspace?: boolean
+  maxDepth?: string | number
+  include?: string | string[]
+  exclude?: string | string[]
+  reportFile?: string
+  backupDir?: string
+  check?: boolean
+  json?: boolean
+}
+interface RestoreCommandArgs extends BaseCommandArgs {
+  reportFile?: string
+  dryRun?: boolean
+  strict?: boolean
+  json?: boolean
+}
+interface ValidateCommandArgs extends BaseCommandArgs {
+  reportFile?: string
+  strict?: boolean
+  json?: boolean
+}
+interface StatusCommandArgs extends BaseCommandArgs {
+  json?: boolean
+}
+
+export interface TailwindcssPatchCommandArgMap {
+  install: InstallCommandArgs
+  extract: ExtractCommandArgs
+  tokens: TokensCommandArgs
+  init: InitCommandArgs
+  migrate: MigrateCommandArgs
+  restore: RestoreCommandArgs
+  validate: ValidateCommandArgs
+  status: StatusCommandArgs
+}
+
+export interface TailwindcssPatchCommandResultMap {
+  install: void
+  extract: ExtractResult
+  tokens: TailwindTokenReport
+  init: void
+  migrate: ConfigFileMigrationReport
+  restore: RestoreConfigFilesResult
+  validate: RestoreConfigFilesResult
+  status: PatchStatusReport
+}
+
+export interface TailwindcssPatchCommandContext<TCommand extends TailwindcssPatchCommand> {
+  cli: CAC
+  command: Command
+  commandName: TCommand
+  args: TailwindcssPatchCommandArgMap[TCommand]
+  cwd: string
+  logger: typeof logger
+  loadConfig: () => Promise<TailwindcssConfigResult>
+  loadPatchOptions: (overrides?: TailwindCssPatchOptions) => Promise<TailwindCssPatchOptions>
+  createPatcher: (overrides?: TailwindCssPatchOptions) => Promise<import('../api/tailwindcss-patcher').TailwindcssPatcher>
+}
+
+export type TailwindcssPatchCommandDefaultHandlerMap = {
+  [K in TailwindcssPatchCommand]: (
+    context: TailwindcssPatchCommandContext<K>,
+  ) => Promise<TailwindcssPatchCommandResultMap[K]>
+}
+
+export type TailwindcssPatchCommandHandler<TCommand extends TailwindcssPatchCommand> = (
+  context: TailwindcssPatchCommandContext<TCommand>,
+  next: () => Promise<TailwindcssPatchCommandResultMap[TCommand]>,
+) => Promise<TailwindcssPatchCommandResultMap[TCommand]> | TailwindcssPatchCommandResultMap[TCommand]
+
+export type TailwindcssPatchCommandHandlerMap = Partial<{
+  [K in TailwindcssPatchCommand]: TailwindcssPatchCommandHandler<K>
+}>
+
+export interface TailwindcssPatchCliMountOptions {
+  commandPrefix?: string
+  commands?: TailwindcssPatchCommand[]
+  commandOptions?: Partial<Record<TailwindcssPatchCommand, TailwindcssPatchCommandOptions>>
+  commandHandlers?: TailwindcssPatchCommandHandlerMap
+}
+
+export interface TailwindcssPatchCliOptions {
+  name?: string
+  mountOptions?: TailwindcssPatchCliMountOptions
+}

package/src/commands/validate-handler.ts

@@ -0,0 +1,42 @@
+import type { TailwindcssPatchCommandContext } from './types'
+
+import { restoreConfigFiles } from './migrate-config'
+import { resolveValidateCommandArgs } from './migration-args'
+import {
+  logValidateFailureAsJson,
+  logValidateFailureSummary,
+  logValidateSuccessAsJson,
+  logValidateSuccessSummary,
+} from './migration-output'
+import { classifyValidateError, ValidateCommandError } from './validate'
+
+export async function validateCommandDefaultHandler(ctx: TailwindcssPatchCommandContext<'validate'>) {
+  const { args } = ctx
+  const validateArgs = resolveValidateCommandArgs(args)
+  try {
+    const result = await restoreConfigFiles({
+      cwd: ctx.cwd,
+      reportFile: validateArgs.reportFile,
+      dryRun: true,
+      strict: validateArgs.strict,
+    })
+
+    if (args.json) {
+      logValidateSuccessAsJson(result)
+      return result
+    }
+
+    logValidateSuccessSummary(result)
+    return result
+  }
+  catch (error) {
+    const summary = classifyValidateError(error)
+    if (args.json) {
+      logValidateFailureAsJson(summary)
+    }
+    else {
+      logValidateFailureSummary(summary)
+    }
+    throw new ValidateCommandError(summary, { cause: error })
+  }
+}

package/src/commands/validate.ts

@@ -0,0 +1,83 @@
+import type { RestoreConfigFilesResult } from './migration-types'
+
+export const VALIDATE_EXIT_CODES = {
+  OK: 0,
+  REPORT_INCOMPATIBLE: 21,
+  MISSING_BACKUPS: 22,
+  IO_ERROR: 23,
+  UNKNOWN_ERROR: 24,
+} as const
+
+export const VALIDATE_FAILURE_REASONS = [
+  'report-incompatible',
+  'missing-backups',
+  'io-error',
+  'unknown-error',
+] as const
+
+export type ValidateFailureReason = (typeof VALIDATE_FAILURE_REASONS)[number]
+
+export interface ValidateFailureSummary {
+  reason: ValidateFailureReason
+  exitCode: number
+  message: string
+}
+
+export interface ValidateJsonSuccessPayload extends RestoreConfigFilesResult {
+  ok: true
+}
+
+export interface ValidateJsonFailurePayload {
+  ok: false
+  reason: ValidateFailureReason
+  exitCode: number
+  message: string
+}
+
+const IO_ERROR_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'ENOTDIR', 'EMFILE', 'ENFILE'])
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return !!error && typeof error === 'object' && ('code' in error || 'message' in error)
+}
+
+export function classifyValidateError(error: unknown): ValidateFailureSummary {
+  const message = error instanceof Error ? error.message : String(error)
+  if (message.startsWith('Unsupported report kind') || message.startsWith('Unsupported report schema version')) {
+    return {
+      reason: 'report-incompatible',
+      exitCode: VALIDATE_EXIT_CODES.REPORT_INCOMPATIBLE,
+      message,
+    }
+  }
+  if (message.startsWith('Restore failed:')) {
+    return {
+      reason: 'missing-backups',
+      exitCode: VALIDATE_EXIT_CODES.MISSING_BACKUPS,
+      message,
+    }
+  }
+  if (isNodeError(error) && typeof error.code === 'string' && IO_ERROR_CODES.has(error.code)) {
+    return {
+      reason: 'io-error',
+      exitCode: VALIDATE_EXIT_CODES.IO_ERROR,
+      message,
+    }
+  }
+  return {
+    reason: 'unknown-error',
+    exitCode: VALIDATE_EXIT_CODES.UNKNOWN_ERROR,
+    message,
+  }
+}
+
+export class ValidateCommandError extends Error {
+  reason: ValidateFailureReason
+  exitCode: number
+
+  constructor(summary: ValidateFailureSummary, options?: ErrorOptions) {
+    super(summary.message, options)
+    this.name = 'ValidateCommandError'
+    this.reason = summary.reason
+    this.exitCode = summary.exitCode
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,25 @@
+export { fromUnifiedConfig } from '../options/legacy'
+export { normalizeOptions } from '../options/normalize'
+export type {
+  ApplyOptions,
+  CacheOptions,
+  CacheStrategy,
+  ExposeContextOptions,
+  ExtendLengthUnitsOptions,
+  ExtractOptions,
+  NormalizedTailwindCssPatchOptions,
+  NormalizedCacheOptions,
+  NormalizedExtendLengthUnitsOptions,
+  TailwindCssOptions,
+  TailwindCssPatchOptions,
+  TailwindV2Options,
+  TailwindV3Options,
+  TailwindV4Options,
+} from '../options/types'
+export {
+  loadPatchOptionsForWorkspace,
+  loadWorkspaceConfigModule,
+  loadWorkspaceDefu,
+  type TailwindcssConfigModule,
+  type TailwindcssConfigResult,
+} from './workspace'

package/src/config/workspace.ts

@@ -0,0 +1,87 @@
+import type { TailwindCssPatchOptions } from '../types'
+import { pathToFileURL } from 'node:url'
+import path from 'pathe'
+import { fromUnifiedConfig } from '../options/legacy'
+
+export interface TailwindcssConfigModule {
+  CONFIG_NAME: string
+  getConfig: (cwd?: string) => Promise<{ config?: { registry?: unknown, patch?: unknown } }>
+  initConfig: (cwd: string) => Promise<unknown>
+}
+
+export type TailwindcssConfigResult = Awaited<ReturnType<TailwindcssConfigModule['getConfig']>>
+type DefuFn = (...objects: unknown[]) => unknown
+
+let configModulePromise: Promise<TailwindcssConfigModule> | undefined
+let defuPromise: Promise<DefuFn> | undefined
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return !!error && typeof error === 'object' && ('code' in error || 'message' in error)
+}
+
+export function isMissingModuleError(error: unknown, pkgName: string) {
+  if (!isNodeError(error)) {
+    return false
+  }
+
+  const code = error.code
+  if (code !== 'MODULE_NOT_FOUND' && code !== 'ERR_MODULE_NOT_FOUND') {
+    return false
+  }
+
+  const message = error.message ?? ''
+  return message.includes(pkgName) || message.includes(`${pkgName}/dist/`)
+}
+
+function isMissingConfigModuleError(error: unknown) {
+  return isMissingModuleError(error, '@tailwindcss-mangle/config')
+}
+
+function isMissingSharedModuleError(error: unknown) {
+  return isMissingModuleError(error, '@tailwindcss-mangle/shared')
+}
+
+export async function loadWorkspaceConfigModule() {
+  if (!configModulePromise) {
+    configModulePromise = (import('@tailwindcss-mangle/config') as Promise<TailwindcssConfigModule>)
+      .catch(async (error) => {
+        if (!isMissingConfigModuleError(error)) {
+          throw error
+        }
+        const fallback = path.resolve(__dirname, '../../../config/src/index.ts')
+        return import(pathToFileURL(fallback).href) as Promise<TailwindcssConfigModule>
+      })
+  }
+  return configModulePromise
+}
+
+export async function loadWorkspaceDefu() {
+  if (!defuPromise) {
+    defuPromise = (import('@tailwindcss-mangle/shared') as Promise<{ defu: DefuFn }>)
+      .then(mod => mod.defu)
+      .catch(async (error) => {
+        if (!isMissingSharedModuleError(error)) {
+          throw error
+        }
+        const fallback = path.resolve(__dirname, '../../../shared/src/utils.ts')
+        const mod = await import(pathToFileURL(fallback).href) as { defu: DefuFn }
+        return mod.defu
+      })
+  }
+  return defuPromise
+}
+
+export async function loadPatchOptionsForWorkspace(cwd: string, overrides?: TailwindCssPatchOptions) {
+  const merge = await loadWorkspaceDefu()
+  const configModule = await loadWorkspaceConfigModule()
+  const { config } = await configModule.getConfig(cwd)
+  if (config && typeof config === 'object' && 'patch' in config && config.patch !== undefined) {
+    throw new Error('Legacy workspace config field "patch" is no longer supported. Move patcher options under "registry".')
+  }
+
+  const base = config?.registry
+    ? fromUnifiedConfig(config.registry)
+    : {}
+  const merged = merge(overrides ?? {}, base) as TailwindCssPatchOptions
+  return merged
+}

package/src/constants.ts

@@ -0,0 +1,4 @@
+import packageJson from '../package.json'
+
+export const pkgName = 'tailwindcss-patch'
+export const pkgVersion = packageJson.version