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

package/src/runtime/process-tailwindcss.ts

@@ -0,0 +1,115 @@
+import { createRequire } from 'node:module'
+import fs from 'fs-extra'
+import path from 'pathe'
+import postcss from 'postcss'
+import { loadConfig } from 'tailwindcss-config'
+
+const require = createRequire(import.meta.url)
+
+export interface TailwindBuildOptions {
+  cwd: string
+  config?: string
+  majorVersion: 2 | 3 | 4
+  postcssPlugin?: string
+}
+
+function resolveModuleEntry(id: string) {
+  return path.isAbsolute(id) ? id : require.resolve(id)
+}
+
+function resolvePackageRootFromEntry(entry: string) {
+  let current = path.dirname(entry)
+  while (current && current !== path.dirname(current)) {
+    const packageJsonPath = path.join(current, 'package.json')
+    if (fs.pathExistsSync(packageJsonPath)) {
+      return current
+    }
+    current = path.dirname(current)
+  }
+  return undefined
+}
+
+function clearTailwindV3RuntimeState(pluginName: string) {
+  try {
+    const entry = resolveModuleEntry(pluginName)
+    const root = resolvePackageRootFromEntry(entry)
+    if (!root) {
+      return
+    }
+
+    const sharedStatePath = path.join(root, 'lib/lib/sharedState.js')
+    if (!fs.pathExistsSync(sharedStatePath)) {
+      return
+    }
+
+    const sharedState = require.cache[sharedStatePath]?.exports as
+      | {
+      contextMap?: Map<unknown, unknown>
+      configContextMap?: Map<unknown, unknown>
+      contextSourcesMap?: Map<unknown, unknown>
+      sourceHashMap?: Map<unknown, unknown>
+    }
+      | undefined
+    sharedState?.contextMap?.clear()
+    sharedState?.configContextMap?.clear()
+    sharedState?.contextSourcesMap?.clear()
+    sharedState?.sourceHashMap?.clear()
+
+    for (const candidate of ['lib/plugin.js', 'lib/index.js']) {
+      const runtimeEntry = path.join(root, candidate)
+      if (!fs.pathExistsSync(runtimeEntry)) {
+        continue
+      }
+
+      const runtimeModule = require.cache[runtimeEntry]?.exports as
+        | {
+        contextRef?: { value?: unknown[] }
+      }
+        | undefined
+      runtimeModule?.contextRef?.value?.splice(0, runtimeModule.contextRef.value.length)
+      break
+    }
+  }
+  catch {
+    // best-effort cleanup for Tailwind v3 runtime state
+  }
+}
+
+async function resolveConfigPath(options: TailwindBuildOptions) {
+  if (options.config && path.isAbsolute(options.config)) {
+    return options.config
+  }
+
+  const result = await loadConfig({ cwd: options.cwd })
+  if (!result) {
+    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`)
+  }
+  return result.filepath
+}
+
+export async function runTailwindBuild(options: TailwindBuildOptions) {
+  const configPath = await resolveConfigPath(options)
+  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? '@tailwindcss/postcss' : 'tailwindcss')
+
+  if (options.majorVersion === 3) {
+    clearTailwindV3RuntimeState(pluginName)
+  }
+
+  if (options.majorVersion === 4) {
+    return postcss([
+      require(pluginName)({
+        config: configPath,
+      }),
+    ]).process('@import \'tailwindcss\';', {
+      from: undefined,
+    })
+  }
+
+  return postcss([
+    require(pluginName)({
+      config: configPath,
+    }),
+  ]).process('@tailwind base;@tailwind components;@tailwind utilities;', {
+    from: undefined,
+  })
+}

package/src/types.ts

@@ -0,0 +1,159 @@
+import type { SourceEntry } from '@tailwindcss/oxide'
+import type { Node, Rule } from 'postcss'
+import type { Config } from 'tailwindcss'
+import type {
+  ApplyOptions,
+  CacheOptions,
+  CacheStrategy,
+  ExposeContextOptions,
+  ExtendLengthUnitsOptions,
+  ExtractOptions,
+  NormalizedTailwindCssPatchOptions,
+  TailwindCssOptions,
+  TailwindCssPatchOptions,
+  TailwindV2Options,
+  TailwindV3Options,
+  TailwindV4Options,
+} from './options/types'
+
+type TailwindcssClassCacheEntry = Rule | {
+  layer: string
+  options: Record<string, any>
+  sort: Record<string, any>
+}
+
+export type TailwindcssClassCache = Map<string, TailwindcssClassCacheEntry[]>
+
+export interface TailwindcssRuntimeContext {
+  applyClassCache: Map<any, any>
+  candidateRuleCache: Map<
+    string,
+    Set<
+      [
+        {
+          arbitrary: any
+          index: any
+          layer: string
+          options: any[]
+          parallelIndex: any
+          parentLayer: string
+          variants: any
+        },
+        Node,
+      ]
+    >
+  >
+  candidateRuleMap: Map<string | string, [object, Node][]>
+  changedContent: any[]
+  classCache: TailwindcssClassCache
+  disposables: any[]
+  getClassList: (...args: any[]) => any
+  getClassOrder: (...args: any[]) => any
+  getVariants: (...args: any[]) => any
+  markInvalidUtilityCandidate: (...args: any[]) => any
+  markInvalidUtilityNode: (...args: any[]) => any
+  notClassCache: Set<string>
+  offsets: {
+    layerPositions: object
+    offsets: object
+    reservedVariantBits: any
+    variantOffsets: Map<string, any>
+  }
+  postCssNodeCache: Map<object, [Node]>
+  ruleCache: Set<[object, Node]>
+  stylesheetCache: Record<string, Set<any>>
+  tailwindConfig: Config
+  userConfigPath: string | null
+  variantMap: Map<string, [[object, (...args: any[]) => unknown]]>
+  variantOptions: Map<string, object>
+}
+
+export interface ExtractResult {
+  classList: string[]
+  classSet: Set<string>
+  filename?: string
+}
+
+export interface TailwindTokenLocation {
+  rawCandidate: string
+  file: string
+  relativeFile: string
+  extension: string
+  start: number
+  end: number
+  length: number
+  line: number
+  column: number
+  lineText: string
+}
+
+export type TailwindTokenFileKey = 'relative' | 'absolute'
+
+export interface TailwindTokenReport {
+  entries: TailwindTokenLocation[]
+  filesScanned: number
+  sources: SourceEntry[]
+  skippedFiles: {
+    file: string
+    reason: string
+  }[]
+}
+
+export type TailwindTokenByFileMap = Record<string, TailwindTokenLocation[]>
+
+export interface TailwindPatchRuntime {
+  options: NormalizedTailwindCssPatchOptions
+  majorVersion: 2 | 3 | 4
+}
+
+export type {
+  ApplyOptions,
+  CacheOptions,
+  CacheStrategy,
+  ExposeContextOptions,
+  ExtendLengthUnitsOptions,
+  ExtractOptions,
+  NormalizedTailwindCssPatchOptions,
+  TailwindCssOptions,
+  TailwindCssPatchOptions,
+  TailwindV2Options,
+  TailwindV3Options,
+  TailwindV4Options,
+}
+
+export interface ILengthUnitsPatchOptions {
+  units: string[]
+  lengthUnitsFilePath?: string
+  variableName?: string
+  overwrite?: boolean
+  destPath?: string
+}
+
+export type PatchCheckStatus = 'applied' | 'not-applied' | 'skipped' | 'unsupported'
+
+export type PatchName = 'exposeContext' | 'extendLengthUnits'
+
+export interface PatchStatusEntry {
+  name: PatchName
+  status: PatchCheckStatus
+  reason?: string
+  files: string[]
+}
+
+export interface PatchStatusReport {
+  package: {
+    name?: string
+    version?: string
+    root: string
+  }
+  majorVersion: 2 | 3 | 4
+  entries: PatchStatusEntry[]
+}
+
+export type {
+  CacheClearOptions,
+  CacheClearResult,
+  CacheClearScope,
+  CacheContextMetadata,
+  CacheReadMeta,
+} from './cache/types'

package/src/utils.ts

@@ -0,0 +1,52 @@
+export function isObject(val: any) {
+  return val !== null && typeof val === 'object' && Array.isArray(val) === false
+};
+
+export interface StringChange {
+  start: number
+  end: number
+  replacement: string
+}
+
+/**
+ * Apply the changes to the string such that a change in the length
+ * of the string does not break the indexes of the subsequent changes.
+ */
+export function spliceChangesIntoString(str: string, changes: StringChange[]) {
+  // If there are no changes, return the original string
+  const firstChange = changes[0]
+  if (!firstChange) {
+    return str
+  }
+
+  // Sort all changes in order to make it easier to apply them
+  changes.sort((a, b) => {
+    return a.end - b.end || a.start - b.start
+  })
+
+  // Append original string between each chunk, and then the chunk itself
+  // This is sort of a String Builder pattern, thus creating less memory pressure
+  let result = ''
+
+  let previous = firstChange
+
+  result += str.slice(0, previous.start)
+  result += previous.replacement
+
+  for (let i = 1; i < changes.length; ++i) {
+    const change = changes[i]
+    if (!change) {
+      continue
+    }
+
+    result += str.slice(previous.end, change.start)
+    result += change.replacement
+
+    previous = change
+  }
+
+  // Add leftover string from last chunk to end
+  result += str.slice(previous.end)
+
+  return result
+}