chore(deps): upgrade

Author: sonofmagic

packages/config/test/config-loadC12.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest'
+
+describe('getConfig caching', () => {
+  it('imports c12 once and reuses the cached promise', async () => {
+    const importCalls = vi.fn()
+    const loadConfig = vi.fn().mockResolvedValue({ config: { ok: true } })
+
+    vi.doMock('c12', () => {
+      importCalls()
+      return {
+        loadConfig,
+        createDefineConfig: () => (value: unknown) => value,
+      }
+    })
+
+    vi.resetModules()
+    const { getConfig } = await import('../src/config')
+
+    await getConfig('/tmp/one')
+    await getConfig('/tmp/two')
+
+    expect(importCalls).toHaveBeenCalledTimes(1)
+    expect(loadConfig).toHaveBeenCalledTimes(2)
+
+    vi.doUnmock('c12')
+    vi.resetModules()
+  })
+})

packages/config/test/defaults.test.ts

@@ -24,6 +24,14 @@ describe('defaults', () => {
     expect(omitCwdPath(getDefaultRegistryConfig())).toMatchSnapshot()
   })
 
+  it('exposes default pipeline include/exclude patterns', () => {
+    const transformer = getDefaultTransformerConfig()
+
+    expect(transformer.sources.include.some(re => re.test('index.html'))).toBe(true)
+    expect(transformer.sources.include.some(re => re.test('styles.css'))).toBe(true)
+    expect(transformer.sources.exclude).toEqual([])
+  })
+
   it('getDefaultUserConfig', () => {
     expect(normaliseRegex(omitCwdPath(getDefaultUserConfig()))).toMatchSnapshot()
   })

packages/config/test/loadC12-cache.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from 'vitest'
+
+describe('loadC12 caching', () => {
+  it('imports c12 once and reuses the cached promise across calls', async () => {
+    const importCounter = vi.fn()
+    const loadConfig = vi.fn()
+      .mockResolvedValueOnce({ config: { first: true } })
+      .mockResolvedValueOnce({ config: { second: true } })
+
+    vi.doMock('c12', () => {
+      importCounter()
+      return {
+        loadConfig,
+        createDefineConfig: () => (value: unknown) => value,
+      }
+    })
+
+    vi.resetModules()
+    const { getConfig } = await import('../src/config')
+
+    const first = await getConfig('/tmp/first')
+    const second = await getConfig('/tmp/second')
+
+    expect(importCounter).toHaveBeenCalledTimes(1)
+    expect(loadConfig).toHaveBeenCalledTimes(2)
+    expect(loadConfig).toHaveBeenLastCalledWith(expect.objectContaining({ cwd: '/tmp/second' }))
+    expect(first.config).toEqual({ first: true })
+    expect(second.config).toEqual({ second: true })
+
+    vi.resetModules()
+    vi.doUnmock('c12')
+  })
+})

packages/shared/test/classGenerator.behavior.test.ts

@@ -50,6 +50,20 @@ describe('ClassGenerator behaviour', () => {
     expect(again).toBe(first)
   })
 
+  it('skips logging when reserved name is encountered without log flag', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
+    const generator = new ClassGenerator({
+      reserveClassName: [/^tw-a$/u],
+    })
+
+    const result = generator.generateClassName('foo')
+    expect(result.name).toBe('tw-b')
+    expect(generator.newClassSize).toBe(2)
+    expect(logSpy).not.toHaveBeenCalled()
+
+    logSpy.mockRestore()
+  })
+
   it('falls back to default generator and skips reserved results', () => {
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined)
     const generator = new ClassGenerator({

packages/shared/test/index.test.ts

@@ -1,7 +1,7 @@
-import * as shared from '@/index'
-
 describe('package entrypoint', () => {
-  it('exposes key helpers', () => {
+  it('exposes key helpers', async () => {
+    const shared = await import('@/index')
+
     expect(typeof shared.ClassGenerator).toBe('function')
     expect(typeof shared.defu).toBe('function')
     expect(typeof shared.defaultMangleClassFilter).toBe('function')

packages/shared/test/utils-extra.test.ts

@@ -66,6 +66,11 @@ describe('shared utils', () => {
     expect(() => regExpTest('invalid' as unknown as (string | RegExp)[], 'foo')).toThrowError(TypeError)
   })
 
+  it('returns false for empty or non-regexp entries', () => {
+    expect(regExpTest([], 'foo')).toBe(false)
+    expect(regExpTest([123 as unknown as RegExp], 'foo')).toBe(false)
+  })
+
   it('exposes alphabet characters', () => {
     expect(acceptChars.length).toBe(26)
     expect(acceptChars[0]).toBe('a')