chore: wip

Author: chrisbbreuer

packages/headwind/src/generator.ts

@@ -2,23 +2,73 @@ import type { CSSRule, HeadwindConfig, ParsedClass } from './types'
 import { builtInRules } from './rules'
 import { parseClass } from './parser'
 
+/**
+ * Deep merge objects
+ */
+function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+  const result = { ...target }
+  for (const key in source) {
+    const sourceValue = source[key]
+    const targetValue = result[key]
+    if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue) && targetValue && typeof targetValue === 'object' && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue)
+    }
+    else if (sourceValue !== undefined) {
+      result[key] = sourceValue as any
+    }
+  }
+  return result
+}
+
 /**
  * Generates CSS rules from parsed utility classes
  */
 export class CSSGenerator {
   private rules: Map<string, CSSRule[]> = new Map()
 
-  constructor(private config: HeadwindConfig) {}
+  constructor(private config: HeadwindConfig) {
+    // Merge preset themes into the main config theme
+    if (config.presets && config.presets.length > 0) {
+      for (const preset of config.presets) {
+        if (preset.theme) {
+          this.config.theme = deepMerge(this.config.theme, preset.theme)
+        }
+      }
+    }
+  }
 
   /**
    * Generate CSS for a utility class
    */
   generate(className: string): void {
     const parsed = parseClass(className)
 
-    // Check if class is blocklisted
-    if (this.config.blocklist.includes(className)) {
-      return
+    // Check if class is blocklisted (supports wildcards)
+    for (const pattern of this.config.blocklist) {
+      if (pattern.includes('*')) {
+        // Convert wildcard pattern to regex
+        const regexPattern = pattern.replace(/\*/g, '.*')
+        const regex = new RegExp(`^${regexPattern}$`)
+        if (regex.test(className)) {
+          return
+        }
+      }
+      else if (pattern === className) {
+        // Exact match
+        return
+      }
+    }
+
+    // Try custom rules from config first (allows overriding built-in rules)
+    for (const [pattern, handler] of this.config.rules) {
+      const match = className.match(pattern)
+      if (match) {
+        const properties = handler(match)
+        if (properties) {
+          this.addRule(parsed, properties)
+          return
+        }
+      }
     }
 
     // Try built-in rules
@@ -36,18 +86,6 @@ export class CSSGenerator {
       }
     }
 
-    // Try custom rules from config
-    for (const [pattern, handler] of this.config.rules) {
-      const match = className.match(pattern)
-      if (match) {
-        const properties = handler(match)
-        if (properties) {
-          this.addRule(parsed, properties)
-          return
-        }
-      }
-    }
-
     // Check shortcuts
     const shortcut = this.config.shortcuts[className]
     if (shortcut) {

packages/headwind/src/rules-interactivity.ts

@@ -4,6 +4,10 @@ import type { UtilityRule } from './rules'
 
 // Filter utilities
 export const filterRule: UtilityRule = (parsed) => {
+  // Handle filter-none
+  if (parsed.raw === 'filter-none') {
+    return { filter: 'none' }
+  }
   if (parsed.utility === 'blur' && parsed.value) {
     const blurMap: Record<string, string> = {
       none: '0',
@@ -53,6 +57,10 @@ export const filterRule: UtilityRule = (parsed) => {
 }
 
 export const backdropFilterRule: UtilityRule = (parsed) => {
+  // Handle backdrop-filter-none
+  if (parsed.raw === 'backdrop-filter-none') {
+    return { 'backdrop-filter': 'none' }
+  }
   if (parsed.utility === 'backdrop-blur' && parsed.value) {
     return { 'backdrop-filter': `blur(${parsed.value}px)` }
   }

packages/headwind/src/rules-transforms.ts

@@ -258,14 +258,30 @@ export const transitionBehaviorRule: UtilityRule = (parsed) => {
 }
 
 export const animationRule: UtilityRule = (parsed) => {
+  if (parsed.utility !== 'animate') {
+    return undefined
+  }
+
   const animations: Record<string, string> = {
-    'animate-none': 'none',
-    'animate-spin': 'spin 1s linear infinite',
-    'animate-ping': 'ping 1s cubic-bezier(0, 0, 0.2, 1) infinite',
-    'animate-pulse': 'pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
-    'animate-bounce': 'bounce 1s infinite',
+    'none': 'none',
+    'spin': 'spin 1s linear infinite',
+    'ping': 'ping 1s cubic-bezier(0, 0, 0.2, 1) infinite',
+    'pulse': 'pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
+    'bounce': 'bounce 1s infinite',
+  }
+
+  // Support arbitrary animation values
+  if (parsed.arbitrary && parsed.value) {
+    // Replace underscores with spaces for arbitrary animation values
+    return { animation: parsed.value.replace(/_/g, ' ') }
   }
-  return animations[parsed.raw] ? { animation: animations[parsed.raw] } : undefined
+
+  // Support predefined animations
+  if (parsed.value && animations[parsed.value]) {
+    return { animation: animations[parsed.value] }
+  }
+
+  return undefined
 }
 
 export const transformsRules: UtilityRule[] = [