@cwcss/crosswind 0.1.4

package/src/scanner.ts

@@ -0,0 +1,84 @@
+import type { CompileClassTransformer } from './transformer-compile-class'
+import type { ExtractClassesOptions } from './parser'
+import { Glob } from 'bun'
+import { extractClasses } from './parser'
+
+export interface ScanResult {
+  classes: Set<string>
+  transformedFiles: Map<string, string>
+}
+
+/**
+ * Scans files for utility classes using Bun's fast Glob API
+ */
+export class Scanner {
+  constructor(
+    private patterns: string[],
+    private transformer: CompileClassTransformer | null | undefined = undefined,
+    private extractOptions: ExtractClassesOptions | undefined = undefined,
+  ) {}
+
+  /**
+   * Scan all files matching the patterns and extract utility classes
+   */
+  async scan(): Promise<ScanResult> {
+    const allClasses = new Set<string>()
+    const transformedFiles = new Map<string, string>()
+
+    // Use Promise.all to scan all patterns concurrently for better performance
+    await Promise.all(
+      this.patterns.map(async (pattern) => {
+        const glob = new Glob(pattern)
+
+        // Bun's glob.scan() returns an async iterable
+        for await (const file of glob.scan('.')) {
+          try {
+            let content = await Bun.file(file).text()
+
+            // Apply transformer if enabled
+            if (this.transformer) {
+              const result = this.transformer.processFile(content)
+              if (result.hasChanges) {
+                transformedFiles.set(file, result.content)
+                content = result.content
+              }
+            }
+
+            const classes = extractClasses(content, this.extractOptions)
+
+            for (const cls of classes) {
+              allClasses.add(cls)
+            }
+          }
+          catch {
+            // Silently skip files that can't be read
+            // (e.g., binary files, permission issues)
+            continue
+          }
+        }
+      }),
+    )
+
+    return { classes: allClasses, transformedFiles }
+  }
+
+  /**
+   * Scan a single file for utility classes
+   */
+  async scanFile(filePath: string): Promise<Set<string>> {
+    try {
+      const content = await Bun.file(filePath).text()
+      return extractClasses(content, this.extractOptions)
+    }
+    catch {
+      return new Set<string>()
+    }
+  }
+
+  /**
+   * Scan content string for utility classes
+   */
+  scanContent(content: string): Set<string> {
+    return extractClasses(content, this.extractOptions)
+  }
+}

package/src/transformer-compile-class.ts

@@ -0,0 +1,275 @@
+import type { CrosswindConfig } from './types'
+
+export interface CompileClassOptions {
+  /**
+   * Trigger string to mark classes for compilation
+   * @default ':hw:'
+   */
+  trigger?: string
+  /**
+   * Prefix for generated class names
+   * @default 'hw-'
+   */
+  classPrefix?: string
+  /**
+   * Hash function to generate class names
+   */
+  hashFn?: (content: string) => string
+  /**
+   * Layer name for compiled classes
+   * @default 'shortcuts'
+   */
+  layer?: string
+}
+
+/**
+ * Simple hash function for generating class names
+ */
+function simpleHash(str: string): string {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i)
+    hash = (hash << 5) - hash + char
+    hash = hash & hash // Convert to 32-bit integer
+  }
+  return Math.abs(hash).toString(36)
+}
+
+/**
+ * Extract compile class markers from content
+ */
+export function extractCompileClasses(
+  content: string,
+  options: CompileClassOptions = {},
+): Map<string, string[]> {
+  const trigger = options.trigger || ':hw:'
+  const compiledClasses = new Map<string, string[]>()
+
+  // Match class attributes with the trigger
+  // Supports: class=":uno: ..." and className=":uno: ..."
+  const classRegex = /(?:class|className)=["']([^"']*)["']/g
+  let match: RegExpExecArray | null
+
+  // eslint-disable-next-line no-cond-assign
+  while ((match = classRegex.exec(content)) !== null) {
+    const fullClass = match[1]
+
+    // Check if it starts with the trigger
+    if (fullClass.trim().startsWith(trigger)) {
+      // Remove the trigger and get the classes
+      const classes = fullClass
+        .replace(trigger, '')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+
+      if (classes.length > 0) {
+        // Generate a unique identifier for this group of classes
+        const classKey = classes.sort().join(' ')
+        if (!compiledClasses.has(classKey)) {
+          compiledClasses.set(classKey, classes)
+        }
+      }
+    }
+  }
+
+  return compiledClasses
+}
+
+/**
+ * Transform content by replacing compile markers with generated class names
+ */
+export function transformContent(
+  content: string,
+  compiledClassMap: Map<string, string>,
+  options: CompileClassOptions = {},
+): string {
+  const trigger = options.trigger || ':hw:'
+  let transformed = content
+
+  const classRegex = /(?:class|className)=["']([^"']*)["']/g
+  let match: RegExpExecArray | null
+
+  // We need to replace in reverse order to maintain string positions
+  const replacements: Array<{ start: number, end: number, replacement: string }> = []
+
+  // eslint-disable-next-line no-cond-assign
+  while ((match = classRegex.exec(content)) !== null) {
+    const fullClass = match[1]
+
+    if (fullClass.trim().startsWith(trigger)) {
+      const classes = fullClass
+        .replace(trigger, '')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+
+      const classKey = classes.sort().join(' ')
+      const generatedClass = compiledClassMap.get(classKey)
+
+      if (generatedClass) {
+        const attrName = match[0].startsWith('class=') ? 'class' : 'className'
+        const quote = match[0].includes('"') ? '"' : '\''
+        const replacement = `${attrName}=${quote}${generatedClass}${quote}`
+
+        replacements.push({
+          start: match.index,
+          end: match.index + match[0].length,
+          replacement,
+        })
+      }
+    }
+  }
+
+  // Apply replacements in reverse order
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const { start, end, replacement } = replacements[i]
+    transformed = transformed.substring(0, start) + replacement + transformed.substring(end)
+  }
+
+  return transformed
+}
+
+/**
+ * Generate class names for compiled classes
+ */
+export function generateCompiledClassNames(
+  compiledClasses: Map<string, string[]>,
+  options: CompileClassOptions = {},
+): Map<string, string> {
+  const classPrefix = options.classPrefix || 'hw-'
+  const hashFn = options.hashFn || simpleHash
+
+  const classMap = new Map<string, string>()
+
+  for (const [classKey] of compiledClasses) {
+    const hash = hashFn(classKey)
+    const generatedClassName = `${classPrefix}${hash}`
+    classMap.set(classKey, generatedClassName)
+  }
+
+  return classMap
+}
+
+/**
+ * Main transformer class
+ */
+export class CompileClassTransformer {
+  private compiledClasses = new Map<string, string[]>()
+  private classNameMap = new Map<string, string>()
+  private options: CompileClassOptions
+
+  constructor(options: CompileClassOptions = {}) {
+    this.options = {
+      trigger: ':hw:',
+      classPrefix: 'hw-',
+      layer: 'shortcuts',
+      ...options,
+    }
+  }
+
+  /**
+   * Process a file and extract compile classes
+   */
+  processFile(content: string): { content: string, hasChanges: boolean } {
+    const extracted = extractCompileClasses(content, this.options)
+
+    if (extracted.size === 0) {
+      return { content, hasChanges: false }
+    }
+
+    // Merge with existing compiled classes
+    let hasNewClasses = false
+    for (const [key, classes] of extracted) {
+      if (!this.compiledClasses.has(key)) {
+        this.compiledClasses.set(key, classes)
+        hasNewClasses = true
+      }
+    }
+
+    // Generate class names if we have new classes
+    if (hasNewClasses || this.classNameMap.size !== this.compiledClasses.size) {
+      this.classNameMap = generateCompiledClassNames(this.compiledClasses, this.options)
+    }
+
+    // Transform the content
+    const transformed = transformContent(content, this.classNameMap, this.options)
+
+    return {
+      content: transformed,
+      hasChanges: transformed !== content,
+    }
+  }
+
+  /**
+   * Get all compiled classes and their generated names
+   */
+  getCompiledClasses(): Map<string, { className: string, utilities: string[] }> {
+    const result = new Map<string, { className: string, utilities: string[] }>()
+
+    for (const [key, utilities] of this.compiledClasses) {
+      const className = this.classNameMap.get(key)
+      if (className) {
+        result.set(key, { className, utilities })
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Generate CSS for compiled classes
+   */
+  generateCSS(config: CrosswindConfig, generator: any): string {
+    const compiledClasses = this.getCompiledClasses()
+    let css = ''
+
+    for (const [, { className, utilities }] of compiledClasses) {
+      // Generate CSS for each utility in the group
+      for (const utility of utilities) {
+        generator.generate(utility)
+      }
+
+      // Get the generated CSS and wrap it with the compiled class name
+      const _generatedCSS = generator.toCSS(false)
+
+      // We need to extract just the CSS for these utilities
+      // This is a simplified approach - in production you'd want to track
+      // which rules were generated for which utilities
+      css += `\n/* Compiled class: ${className} */\n`
+      css += `/* Original utilities: ${utilities.join(' ')} */\n`
+    }
+
+    return css
+  }
+
+  /**
+   * Reset the transformer state
+   */
+  reset(): void {
+    this.compiledClasses.clear()
+    this.classNameMap.clear()
+  }
+
+  /**
+   * Get statistics about compiled classes
+   */
+  getStats(): {
+    totalGroups: number
+    totalUtilities: number
+    averageUtilitiesPerGroup: number
+  } {
+    let totalUtilities = 0
+    for (const [, utilities] of this.compiledClasses) {
+      totalUtilities += utilities.length
+    }
+
+    return {
+      totalGroups: this.compiledClasses.size,
+      totalUtilities,
+      averageUtilitiesPerGroup: this.compiledClasses.size > 0
+        ? totalUtilities / this.compiledClasses.size
+        : 0,
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,197 @@
+export interface CompileClassConfig {
+  /**
+   * Enable compile class transformer
+   * @default false
+   */
+  enabled?: boolean
+  /**
+   * Trigger string to mark classes for compilation
+   * @default ':hw:'
+   */
+  trigger?: string
+  /**
+   * Prefix for generated class names
+   * @default 'hw-'
+   */
+  classPrefix?: string
+  /**
+   * Layer name for compiled classes
+   * @default 'shortcuts'
+   */
+  layer?: string
+}
+
+export interface AttributifyConfig {
+  /**
+   * Enable attributify mode
+   * Allows using HTML attributes instead of class names
+   * e.g., <div hw-flex hw-bg="blue-500">
+   * @default false
+   */
+  enabled?: boolean
+  /**
+   * Prefix for attributify attributes (to avoid conflicts with HTML attributes)
+   * e.g., with prefix 'hw-': <div hw-flex hw-bg="blue-500">
+   * @default 'hw-'
+   */
+  prefix?: string
+  /**
+   * Attributes to ignore (won't be treated as utilities)
+   * @default ['class', 'className', 'style', 'id', ...]
+   */
+  ignoreAttributes?: string[]
+}
+
+export interface BracketSyntaxConfig {
+  /**
+   * Enable bracket/grouped syntax
+   * Allows grouping utilities like: flex[col jc-center ai-center] or text[white 2rem 700]
+   * @default false
+   */
+  enabled?: boolean
+  /**
+   * Enable colon syntax for simple values
+   * e.g., bg:black, w:100%, text:white
+   * @default false
+   */
+  colonSyntax?: boolean
+  /**
+   * Mapping of shorthand abbreviations to full utility names
+   * e.g., { 'jc': 'justify', 'ai': 'items', 'col': 'col' }
+   */
+  aliases?: Record<string, string>
+}
+
+export interface CrosswindConfig {
+  content: string[]
+  output: string
+  minify: boolean
+  watch: boolean
+  verbose?: boolean
+  theme: Theme
+  shortcuts: Record<string, string | string[]>
+  rules: CustomRule[]
+  variants: VariantConfig
+  safelist: string[]
+  blocklist: string[]
+  preflights: Preflight[]
+  presets: Preset[]
+  compileClass?: CompileClassConfig
+  attributify?: AttributifyConfig
+  bracketSyntax?: BracketSyntaxConfig
+  /** Generate :root CSS variables from theme colors (e.g., --monokai-bg: #2d2a2e) */
+  cssVariables?: boolean
+}
+
+export interface Theme {
+  colors: Record<string, string | Record<string, string>>
+  spacing: Record<string, string>
+  fontSize: Record<string, [string, { lineHeight: string }]>
+  fontFamily: Record<string, string[]>
+  screens: Record<string, string>
+  borderRadius: Record<string, string>
+  boxShadow: Record<string, string>
+  /** Extend theme values without replacing defaults */
+  extend?: Partial<Omit<Theme, 'extend'>>
+}
+
+export interface VariantConfig {
+  'responsive': boolean
+  'hover': boolean
+  'focus': boolean
+  'active': boolean
+  'disabled': boolean
+  'dark': boolean
+  // Group/Peer
+  'group': boolean
+  'peer': boolean
+  // Pseudo-elements
+  'before': boolean
+  'after': boolean
+  'marker': boolean
+  // Pseudo-classes - Basic
+  'first': boolean
+  'last': boolean
+  'odd': boolean
+  'even': boolean
+  'first-of-type': boolean
+  'last-of-type': boolean
+  'visited': boolean
+  'checked': boolean
+  'focus-within': boolean
+  'focus-visible': boolean
+  // Pseudo-classes - Form states
+  'placeholder': boolean
+  'selection': boolean
+  'file': boolean
+  'required': boolean
+  'valid': boolean
+  'invalid': boolean
+  'read-only': boolean
+  'autofill': boolean
+  // Pseudo-classes - Additional states
+  'open': boolean
+  'closed': boolean
+  'empty': boolean
+  'enabled': boolean
+  'only': boolean
+  'target': boolean
+  'indeterminate': boolean
+  'default': boolean
+  'optional': boolean
+  // Media
+  'print': boolean
+  // Direction
+  'rtl': boolean
+  'ltr': boolean
+  // Motion
+  'motion-safe': boolean
+  'motion-reduce': boolean
+  // Contrast
+  'contrast-more': boolean
+  'contrast-less': boolean
+}
+
+export interface ParsedClass {
+  raw: string
+  variants: string[]
+  utility: string
+  value?: string
+  important: boolean
+  arbitrary: boolean
+  typeHint?: string // Type hint for arbitrary values, e.g., 'color' in text-[color:var(--muted)]
+}
+
+export interface CSSRule {
+  selector: string
+  properties: Record<string, string>
+  mediaQuery?: string
+  childSelector?: string // For utilities like space-x that need child selectors
+}
+
+export interface UtilityRuleResult {
+  properties: Record<string, string>
+  childSelector?: string
+  pseudoElement?: string // e.g., '::placeholder' — appended to selector without space
+}
+
+export type CustomRule = [RegExp, (match: RegExpMatchArray) => Record<string, string> | undefined]
+
+export interface Preflight {
+  getCSS: () => string
+}
+
+export interface Preset {
+  name: string
+  theme?: Partial<Theme>
+  rules?: CustomRule[]
+  shortcuts?: Record<string, string | string[]>
+  variants?: Partial<VariantConfig>
+  preflights?: Preflight[]
+}
+
+type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
+}
+
+export type CrosswindOptions = DeepPartial<CrosswindConfig>