chore: bump version

Author: sonofmagic

.changeset/add-sync-class-set.md

@@ -0,0 +1,5 @@
+---
+'tailwindcss-patch': minor
+---
+
+Add `getClassSetSync` along with synchronous cache utilities so consumers that cannot await the async API can still collect Tailwind classes.

packages/tailwindcss-patch/src/api/tailwindcss-patcher.ts

@@ -139,6 +139,15 @@ export class TailwindcssPatcher {
     return collectClassesFromContexts(contexts, this.options.filter)
   }
 
+  private collectClassSetSync(): Set<string> {
+    if (this.majorVersion === 4) {
+      throw new Error('getClassSetSync is not supported for Tailwind CSS v4 projects. Use getClassSet instead.')
+    }
+
+    const contexts = this.getContexts()
+    return collectClassesFromContexts(contexts, this.options.filter)
+  }
+
   private async mergeWithCache(set: Set<string>) {
     if (!this.options.cache.enabled) {
       return set
@@ -163,12 +172,41 @@ export class TailwindcssPatcher {
     return set
   }
 
+  private mergeWithCacheSync(set: Set<string>) {
+    if (!this.options.cache.enabled) {
+      return set
+    }
+
+    const existing = this.cacheStore.readSync()
+    if (this.options.cache.strategy === 'merge') {
+      for (const value of existing) {
+        set.add(value)
+      }
+      this.cacheStore.writeSync(set)
+    }
+    else {
+      if (set.size > 0) {
+        this.cacheStore.writeSync(set)
+      }
+      else {
+        return existing
+      }
+    }
+
+    return set
+  }
+
   async getClassSet() {
     await this.runTailwindBuildIfNeeded()
     const set = await this.collectClassSet()
     return this.mergeWithCache(set)
   }
 
+  getClassSetSync() {
+    const set = this.collectClassSetSync()
+    return this.mergeWithCacheSync(set)
+  }
+
   async extract(options?: { write?: boolean }): Promise<ExtractResult> {
     const shouldWrite = options?.write ?? this.options.output.enabled
     const classSet = await this.getClassSet()

packages/tailwindcss-patch/src/cache/store.ts

@@ -9,6 +9,10 @@ export class CacheStore {
     await fs.ensureDir(this.options.dir)
   }
 
+  private ensureDirSync() {
+    fs.ensureDirSync(this.options.dir)
+  }
+
   async write(data: Set<string>): Promise<string | undefined> {
     if (!this.options.enabled) {
       return undefined
@@ -25,6 +29,22 @@ export class CacheStore {
     }
   }
 
+  writeSync(data: Set<string>): string | undefined {
+    if (!this.options.enabled) {
+      return undefined
+    }
+
+    try {
+      this.ensureDirSync()
+      fs.writeJSONSync(this.options.path, Array.from(data))
+      return this.options.path
+    }
+    catch (error) {
+      logger.error('Unable to persist Tailwind class cache', error)
+      return undefined
+    }
+  }
+
   async read(): Promise<Set<string>> {
     if (!this.options.enabled) {
       return new Set()
@@ -53,4 +73,33 @@ export class CacheStore {
 
     return new Set()
   }
+
+  readSync(): Set<string> {
+    if (!this.options.enabled) {
+      return new Set()
+    }
+
+    try {
+      const exists = fs.pathExistsSync(this.options.path)
+      if (!exists) {
+        return new Set()
+      }
+
+      const data = fs.readJSONSync(this.options.path)
+      if (Array.isArray(data)) {
+        return new Set(data.filter((item): item is string => typeof item === 'string'))
+      }
+    }
+    catch (error) {
+      logger.warn('Unable to read Tailwind class cache, removing invalid file.', error)
+      try {
+        fs.removeSync(this.options.path)
+      }
+      catch (cleanupError) {
+        logger.error('Failed to clean up invalid cache file', cleanupError)
+      }
+    }
+
+    return new Set()
+  }
 }

packages/tailwindcss-patch/test/api.tailwindcss-patcher.test.ts

@@ -1,22 +1,23 @@
 import os from 'node:os'
 import fs from 'fs-extra'
 import path from 'pathe'
-import { afterEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { TailwindcssPatcher } from '@/api/tailwindcss-patcher'
 
 const fixturesRoot = path.resolve(__dirname, 'fixtures/v4')
-let tempDir: string | undefined
+let tempDir: string
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'tw-patch-'))
+})
 
 afterEach(async () => {
-  if (tempDir) {
-    await fs.remove(tempDir)
-    tempDir = undefined
-  }
+  await fs.remove(tempDir)
+  vi.restoreAllMocks()
 })
 
 describe('TailwindcssPatcher', () => {
   it('collects classes for Tailwind CSS v4 projects', async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'tw-patch-'))
     const outputFile = path.join(tempDir, 'classes.json')
 
     const patcher = new TailwindcssPatcher({
@@ -39,4 +40,68 @@ describe('TailwindcssPatcher', () => {
     expect(result.classList.length).toBeGreaterThan(0)
     expect(await fs.pathExists(outputFile)).toBe(true)
   })
+
+  it('collects classes synchronously from runtime contexts', () => {
+    const cacheFile = path.join(tempDir, 'cache.json')
+    const patcher = new TailwindcssPatcher({
+      overwrite: false,
+      cache: {
+        enabled: true,
+        dir: tempDir,
+        file: 'cache.json',
+      },
+      tailwind: {
+        packageName: 'tailwindcss-3',
+        version: 3,
+      },
+    })
+
+    const classCache = new Map<string, any>([
+      ['foo', []],
+      ['bar', []],
+    ])
+    vi.spyOn(patcher, 'getContexts').mockReturnValue([
+      {
+        classCache,
+      } as any,
+    ])
+
+    const result = patcher.getClassSetSync()
+
+    expect(result.has('foo')).toBe(true)
+    expect(result.has('bar')).toBe(true)
+    expect(fs.pathExistsSync(cacheFile)).toBe(true)
+    const cacheContent = fs.readJSONSync(cacheFile)
+    expect(cacheContent).toEqual(expect.arrayContaining(['foo', 'bar']))
+  })
+
+  it('falls back to cached classes when runtime contexts are empty', () => {
+    const cacheFile = path.join(tempDir, 'cache.json')
+    fs.writeJSONSync(cacheFile, ['cached-class'])
+
+    const patcher = new TailwindcssPatcher({
+      overwrite: false,
+      cache: {
+        enabled: true,
+        dir: tempDir,
+        file: 'cache.json',
+        strategy: 'overwrite',
+      },
+      tailwind: {
+        packageName: 'tailwindcss-3',
+        version: 3,
+      },
+    })
+
+    vi.spyOn(patcher, 'getContexts').mockReturnValue([
+      {
+        classCache: new Map<string, any>(),
+      } as any,
+    ])
+
+    const result = patcher.getClassSetSync()
+
+    expect(result.size).toBe(1)
+    expect(result.has('cached-class')).toBe(true)
+  })
 })

packages/tailwindcss-patch/test/cache.store.test.ts

@@ -52,4 +52,26 @@ describe('CacheStore', () => {
     expect(restored.size).toBe(0)
     expect(await fs.pathExists(cachePath)).toBe(false)
   })
+
+  it('reads and writes cache data synchronously', () => {
+    const cachePath = path.join(tempDir, 'cache.json')
+    const store = new CacheStore({
+      enabled: true,
+      cwd: tempDir,
+      dir: tempDir,
+      file: 'cache.json',
+      path: cachePath,
+      strategy: 'merge',
+    })
+
+    const initial = store.readSync()
+    expect(initial.size).toBe(0)
+
+    const data = new Set(['foo'])
+    store.writeSync(data)
+
+    const restored = store.readSync()
+    expect(restored.size).toBe(1)
+    expect(restored.has('foo')).toBe(true)
+  })
 })