@tw-enigma/core
Version:
CSS optimization engine for tw-enigma
1,635 lines (1,621 loc) • 394 kB
text/typescript
import { z } from 'zod';
import { EventEmitter } from 'events';
import * as cheerio from 'cheerio';
import { AnyNode } from 'domhandler';
import { ParserOptions } from '@babel/parser';
import { NodePath } from '@babel/traverse';
import * as t from '@babel/types';
export * from '@babel/types';
import { Stats } from 'fs';
import { Result, Plugin } from 'postcss';
export { Plugin, PluginCreator, Result, Root } from 'postcss';
/**
* Backup metadata interface
*/
interface BackupMetadata {
id: string;
originalPath: string;
backupPath: string;
timestamp: Date;
version: string;
checksum: string;
size: number;
description?: string;
tags: string[];
isAutomatic: boolean;
}
/**
* Backup verification result
*/
interface BackupVerification {
isValid: boolean;
checksumMatch: boolean;
fileExists: boolean;
isReadable: boolean;
isValidJson: boolean;
errors: string[];
warnings: string[];
}
/**
* Backup restoration result
*/
interface RestoreResult {
success: boolean;
backupId: string;
originalPath: string;
restoredAt: Date;
errors: string[];
warnings: string[];
backupCreated?: string;
}
/**
* Backup retention policy
*/
interface RetentionPolicy {
maxBackups: number;
maxAge: number;
keepDaily: number;
keepWeekly: number;
keepMonthly: number;
autoCleanup: boolean;
}
/**
* Backup options
*/
interface BackupOptions {
description?: string;
tags?: string[];
compress?: boolean;
encrypt?: boolean;
includeMetadata?: boolean;
}
/**
* Default retention policy
*/
declare const DEFAULT_RETENTION_POLICY: RetentionPolicy;
/**
* Configuration backup manager
*/
declare class ConfigBackup extends EventEmitter {
private configPath;
private backupDir;
private metadataFile;
private retentionPolicy;
private backups;
constructor(configPath: string, backupDir?: string, retentionPolicy?: Partial<RetentionPolicy>);
/**
* Initialize backup system
*/
private initializeBackupSystem;
/**
* Load backup metadata
*/
private loadBackupMetadata;
/**
* Save backup metadata
*/
private saveBackupMetadata;
/**
* Create a backup of the configuration
*/
createBackup(options?: BackupOptions): Promise<BackupMetadata>;
/**
* Restore configuration from backup
*/
restoreFromBackup(backupId: string, createBackupBeforeRestore?: boolean): Promise<RestoreResult>;
/**
* Verify backup integrity
*/
verifyBackup(backupId: string): Promise<BackupVerification>;
/**
* List all backups
*/
listBackups(filter?: {
tags?: string[];
isAutomatic?: boolean;
fromDate?: Date;
toDate?: Date;
}): BackupMetadata[];
/**
* Delete a backup
*/
deleteBackup(backupId: string, force?: boolean): Promise<boolean>;
/**
* Apply retention policy
*/
applyRetentionPolicy(): Promise<{
deleted: string[];
kept: string[];
errors: string[];
}>;
/**
* Get backup statistics
*/
getBackupStatistics(): {
totalBackups: number;
automaticBackups: number;
manualBackups: number;
totalSize: number;
oldestBackup?: Date;
newestBackup?: Date;
corruptedBackups: number;
};
/**
* Generate backup ID
*/
private generateBackupId;
/**
* Calculate checksum for content
*/
private calculateChecksum;
/**
* Extract configuration version from content
*/
private extractConfigVersion;
/**
* Create emergency backup
*/
createEmergencyBackup(reason: string): Promise<BackupMetadata>;
/**
* Get latest backup
*/
getLatestBackup(): BackupMetadata | null;
/**
* Cleanup corrupted backups
*/
cleanupCorruptedBackups(): Promise<string[]>;
}
/**
* Create configuration backup manager
*/
declare function createConfigBackup(configPath: string, backupDir?: string, retentionPolicy?: Partial<RetentionPolicy>): ConfigBackup;
/**
* Quick backup utility
*/
declare function backupConfig(configPath: string, options?: BackupOptions): Promise<BackupMetadata>;
/**
* Quick restore utility
*/
declare function restoreConfig(configPath: string, backupId: string): Promise<RestoreResult>;
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Log levels following Log4j standard
*/
declare const LogLevel: {
readonly TRACE: 0;
readonly DEBUG: 1;
readonly INFO: 2;
readonly WARN: 3;
readonly ERROR: 4;
readonly FATAL: 5;
};
type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
/**
* Log level names for easy reference
*/
declare const LogLevelNames: Record<LogLevel, string>;
/**
* File output options for logging
*/
interface FileOutputOptions {
filePath: string;
format?: 'human' | 'json' | 'csv';
maxSize?: number;
maxFiles?: number;
compress?: boolean;
}
/**
* Progress tracking options
*/
interface ProgressOptions {
total: number;
current?: number;
label?: string;
showPercentage?: boolean;
showETA?: boolean;
}
/**
* Configuration options for the logger
*/
interface LoggerOptions {
level?: LogLevel;
verbose?: boolean;
veryVerbose?: boolean;
quiet?: boolean;
silent?: boolean;
outputFormat?: 'human' | 'json';
colorize?: boolean;
timestamp?: boolean;
component?: string;
fileOutput?: FileOutputOptions;
enableProgressTracking?: boolean;
}
/**
* Structured log entry for JSON output
*/
interface LogEntry {
level: string;
message: string;
timestamp: string;
component?: string;
context?: Record<string, unknown>;
error?: {
name: string;
message: string;
stack?: string;
code?: string;
};
}
/**
* Enhanced error context for detailed logging
*/
interface ErrorContext {
component?: string;
operation?: string;
userId?: string;
requestId?: string;
filePath?: string;
processingTime?: number;
memoryUsage?: number;
fileSize?: number;
compressionRatio?: number;
[key: string]: unknown;
}
/**
* Performance metrics for detailed logging
*/
interface PerformanceMetrics$1 {
memoryUsage: NodeJS.MemoryUsage;
processingTime: number;
fileCount?: number;
totalFileSize?: number;
optimizationRatio?: number;
}
/**
* Centralized logger class for the Tailwind Enigma Core application
*/
declare class Logger {
private level;
private verbose;
private veryVerbose;
private quiet;
private silent;
private outputFormat;
private colorize;
private timestamp;
private component?;
private fileOutput?;
private fileStream?;
private enableProgressTracking;
private progressStates;
constructor(options?: LoggerOptions);
/**
* Initialize file output with rotation support
*/
private initializeFileOutput;
/**
* Rotate log files if size limit exceeded
*/
private rotateLogsIfNeeded;
/**
* Perform log file rotation with optional compression
*/
private rotateLogFiles;
/**
* Set the minimum log level
*/
setLevel(level: LogLevel): void;
/**
* Enable or disable verbose logging
*/
setVerbose(verbose: boolean): void;
/**
* Enable or disable very verbose logging
*/
setVeryVerbose(veryVerbose: boolean): void;
/**
* Enable or disable quiet mode
*/
setQuiet(quiet: boolean): void;
/**
* Enable or disable silent mode
*/
setSilent(silent: boolean): void;
/**
* Set output format
*/
setOutputFormat(format: 'human' | 'json'): void;
/**
* Configure file output
*/
setFileOutput(options: FileOutputOptions): void;
/**
* Disable file output
*/
disableFileOutput(): void;
/**
* Start progress tracking for an operation
*/
startProgress(id: string, options: ProgressOptions): void;
/**
* Update progress for an operation
*/
updateProgress(id: string, current: number, additionalInfo?: string): void;
/**
* Complete progress tracking for an operation
*/
completeProgress(id: string, summary?: string): void;
/**
* Log performance metrics
*/
performanceMetrics(operation: string, metrics: PerformanceMetrics$1, context?: ErrorContext): void;
/**
* Log detailed file operation
*/
fileOperation(operation: string, filePath: string, details?: {
size?: number;
processingTime?: number;
result?: string;
}): void;
/**
* Log step-by-step process details
*/
processStep(step: string, details?: string, context?: ErrorContext): void;
/**
* Create a child logger with additional context
*/
child(component: string, options?: Partial<LoggerOptions>): Logger;
/**
* Check if a log level should be output
*/
private shouldLog;
/**
* Format timestamp
*/
private getTimestamp;
/**
* Create a structured log entry
*/
private createLogEntry;
/**
* Format log entry for human-readable output
*/
private formatHuman;
/**
* Format log entry for CSV output
*/
private formatCSV;
/**
* Output a log entry to console and/or file
*/
private output;
/**
* Core logging method
*/
private log;
/**
* Log a trace message (most verbose)
*/
trace(message: string, context?: ErrorContext): void;
/**
* Log a debug message
*/
debug(message: string, context?: ErrorContext): void;
/**
* Log an info message
*/
info(message: string, context?: ErrorContext): void;
/**
* Log a warning message
*/
warn(message: string, context?: ErrorContext): void;
/**
* Log an error message
*/
error(messageOrError: string | Error, context?: ErrorContext): void;
/**
* Log a fatal error message
*/
fatal(messageOrError: string | Error, context?: ErrorContext): void;
/**
* Log performance timing
*/
timing(operation: string, duration: number, context?: ErrorContext): void;
/**
* Clean up resources (close file streams)
*/
cleanup(): void;
/**
* Get current logger state for debugging
*/
getState(): {
level: LogLevel;
verbose: boolean;
veryVerbose: boolean;
quiet: boolean;
silent: boolean;
fileOutputEnabled: boolean;
progressTrackingEnabled: boolean;
activeProgressCount: number;
};
}
/**
* Default logger instance
*/
declare const logger: Logger;
/**
* Create a logger with specific component context
*/
declare function createLogger(component: string, _options?: Partial<LoggerOptions>): Logger;
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Base error class for all Tailwind Enigma Core errors
* Provides standardized error handling with logging integration
*/
declare abstract class EnigmaError extends Error {
readonly timestamp: Date;
readonly errorId: string;
readonly code: string;
readonly context?: ErrorContext;
readonly cause?: Error;
constructor(message: string, code: string, context?: ErrorContext, cause?: Error);
/**
* Generate a unique error ID for tracking
*/
private generateErrorId;
/**
* Log the error using the centralized logger
*/
private logError;
/**
* Convert error to JSON for structured logging
*/
toJSON(): Record<string, unknown>;
}
/**
* Configuration-related errors
*/
declare class ConfigError extends EnigmaError {
readonly filepath?: string;
constructor(message: string, filepath?: string, cause?: Error, context?: ErrorContext);
}
/**
* File discovery operation errors
*/
declare class FileDiscoveryError$1 extends EnigmaError {
readonly patterns?: string | string[];
constructor(message: string, patterns?: string | string[], cause?: Error, context?: ErrorContext);
}
/**
* HTML parsing and extraction errors
*/
declare class HtmlParsingError$1 extends EnigmaError {
readonly source?: string;
constructor(message: string, source?: string, cause?: Error, context?: ErrorContext);
}
/**
* JavaScript/JSX parsing and extraction errors
*/
declare class JsParsingError$1 extends EnigmaError {
readonly source?: string;
readonly framework?: string;
constructor(message: string, source?: string, framework?: string, cause?: Error, context?: ErrorContext);
}
/**
* CSS processing and optimization errors
*/
declare class CssProcessingError extends EnigmaError {
readonly source?: string;
readonly operation?: string;
constructor(message: string, source?: string, operation?: string, cause?: Error, context?: ErrorContext);
}
/**
* CLI command execution errors
*/
declare class CliError extends EnigmaError {
readonly command?: string;
readonly suggestions?: string[];
constructor(message: string, command?: string, suggestions?: string[], cause?: Error, context?: ErrorContext);
/**
* Display CLI-specific error formatting
*/
displayError(): void;
}
/**
* Validation errors for user input
*/
declare class ValidationError$1 extends EnigmaError {
readonly field?: string;
readonly value?: unknown;
constructor(message: string, field?: string, value?: unknown, cause?: Error, context?: ErrorContext);
}
/**
* Performance and timeout errors
*/
declare class TimeoutError extends EnigmaError {
readonly operation?: string;
readonly timeoutMs?: number;
constructor(message: string, operation?: string, timeoutMs?: number, cause?: Error, context?: ErrorContext);
}
/**
* External dependency errors (libraries, APIs, etc.)
*/
declare class DependencyError extends EnigmaError {
readonly dependency?: string;
readonly version?: string;
constructor(message: string, dependency?: string, version?: string, cause?: Error, context?: ErrorContext);
}
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Validation result with detailed feedback
*/
interface ValidationResult$2 {
isValid: boolean;
errors: ValidationError$1[];
warnings: string[];
suggestions: string[];
performance: {
validationTime: number;
rulesApplied: number;
};
}
/**
* Convenience function for validating configuration
*/
declare function validateConfig(config: unknown, filepath?: string): Promise<ValidationResult$2>;
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Runtime validation configuration
*/
interface RuntimeValidatorConfig {
enabled: boolean;
checkInterval: number;
resourceThresholds: {
memory: number;
cpu: number;
fileHandles: number;
diskSpace: number;
};
performanceBaselines: {
processingTime: number;
memoryUsage: number;
fileOperations: number;
};
securityChecks: {
pathTraversal: boolean;
filePermissions: boolean;
resourceLimits: boolean;
};
autoCorrection: {
enabled: boolean;
maxAttempts: number;
fallbackToDefaults: boolean;
};
}
/**
* Runtime configuration validator
*/
declare class RuntimeValidator extends EventEmitter {
private config;
private validatorConfig;
private isRunning;
private checkInterval?;
private resourceBaselines;
private performanceHistory;
private violationCounts;
constructor(config: EnigmaConfig, validatorConfig?: Partial<RuntimeValidatorConfig>);
/**
* Start runtime validation monitoring
*/
start(): void;
/**
* Stop runtime validation monitoring
*/
stop(): void;
/**
* Update configuration and re-validate
*/
updateConfig(newConfig: EnigmaConfig): ValidationResult$2;
/**
* Validate a specific configuration value at runtime
*/
validateValue(field: string, value: unknown, constraints?: Record<string, unknown>): ValidationResult$2;
/**
* Validate file paths and directories
*/
validatePaths(): Promise<{
isValid: boolean;
errors: string[];
warnings: string[];
}>;
/**
* Validate resource constraints (expected by tests)
*/
validateConstraints(): Promise<{
isValid: boolean;
errors: string[];
warnings: string[];
}>;
/**
* Get current resource usage statistics
*/
getResourceUsage(): Record<string, number>;
/**
* Initialize performance baselines
*/
private initializeBaselines;
/**
* Perform comprehensive runtime checks
*/
private performRuntimeChecks;
/**
* Check resource usage against thresholds
*/
private checkResourceUsage;
/**
* Check performance metrics for degradation
*/
private checkPerformanceMetrics;
/**
* Check security constraints
*/
private checkSecurityConstraints;
/**
* Check configuration consistency
*/
private checkConfigurationConsistency;
/**
* Update performance history for trend analysis
*/
private updatePerformanceHistory;
/**
* Validate configuration change
*/
private validateConfigurationChange;
private validateConcurrency;
private validatePath;
private validateFileSize;
private validateGenericField;
private emitResourceAlert;
private emitPerformanceAlert;
private emitSecurityAlert;
private emitValidationWarning;
}
type Config = EnigmaConfig;
/**
* Environment types for configuration defaults
*/
type Environment = 'development' | 'production' | 'test' | 'ci';
/**
* Fallback priority levels
*/
declare const FallbackPriority: {
readonly USER: 1;
readonly PROJECT: 2;
readonly ENVIRONMENT: 3;
readonly GLOBAL: 4;
readonly SYSTEM: 5;
};
type FallbackPriority = (typeof FallbackPriority)[keyof typeof FallbackPriority];
/**
* Configuration source metadata
*/
interface ConfigSource {
priority: FallbackPriority;
source: string;
environment?: Environment;
timestamp: Date;
validated: boolean;
}
/**
* Default configuration values by environment
*/
declare const ENVIRONMENT_DEFAULTS: Record<Environment, Partial<Config>>;
/**
* System-level safe defaults (lowest priority fallback)
*/
declare const SYSTEM_DEFAULTS: Config;
/**
* Global configuration paths for fallback resolution
*/
declare const GLOBAL_CONFIG_PATHS: string[];
/**
* Project-level configuration paths
*/
declare const PROJECT_CONFIG_PATHS: string[];
/**
* Configuration defaults manager
*/
declare class ConfigDefaults {
private environment;
private fallbackChain;
constructor(environment?: Environment);
/**
* Detect current environment
*/
private detectEnvironment;
/**
* Get comprehensive defaults with progressive fallback
*/
getDefaults(): Config;
/**
* Build configuration using progressive fallback strategy
*/
private buildFallbackChain;
/**
* Get global configuration defaults
*/
private getGlobalDefaults;
/**
* Get project-level configuration defaults
*/
private getProjectDefaults;
/**
* Merge configurations with deep merge strategy
*/
private mergeConfigs;
/**
* Add configuration source to fallback chain
*/
private addToChain;
/**
* Validate configuration defaults
*/
private validateDefaults;
/**
* Check if configuration is valid
*/
private isValidConfig;
/**
* Log fallback chain for debugging
*/
private logFallbackChain;
/**
* Get fallback chain information
*/
getFallbackChain(): ConfigSource[];
/**
* Get environment-specific defaults
*/
getEnvironmentDefaults(env?: Environment): Partial<Config>;
/**
* Create configuration with defaults applied (expected by tests)
*/
createConfigWithDefaults(partialConfig: Partial<Config>): Config;
/**
* Check if path is safe for configuration
*/
isSafePath(path: string): boolean;
/**
* Get safe default paths for different purposes
*/
getSafeDefaults(): {
outputDir: string;
cacheDir: string;
tempDir: string;
logDir: string;
};
/**
* Create environment-specific configuration
*/
createEnvironmentConfig(env: Environment, overrides?: Partial<Config>): Config;
/**
* Validate configuration against environment constraints
*/
validateEnvironmentConfig(config: Config, env?: Environment): {
valid: boolean;
warnings: string[];
errors: string[];
};
}
/**
* Create default configuration manager
*/
declare function createConfigDefaults(environment?: Environment): ConfigDefaults;
/**
* Get quick defaults for current environment
*/
declare function getQuickDefaults(): Config;
/**
* Get safe defaults with minimal configuration
*/
declare function getSafeDefaults(): Config;
/**
* Get environment-specific defaults (expected by tests)
*/
declare function getEnvironmentDefaults(environment: Environment): Partial<Config>;
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Safe update operation result
*/
interface SafeUpdateResult {
success: boolean;
filepath: string;
backupPath?: string;
transactionId: string;
timestamp: Date;
validation?: ValidationResult$2;
error?: ConfigError;
rollbackAvailable: boolean;
changes: {
added: string[];
modified: string[];
removed: string[];
};
}
/**
* Update transaction for atomic operations
*/
interface UpdateTransaction {
id: string;
timestamp: Date;
filepath: string;
originalContent: string;
newContent: string;
backupPath: string;
tempPath: string;
status: 'pending' | 'committed' | 'rolled-back' | 'failed';
validation?: ValidationResult$2;
}
/**
* Safe update options
*/
interface SafeUpdateOptions {
validateBeforeWrite: boolean;
createBackup: boolean;
backupDirectory?: string;
maxBackups: number;
atomicWrite: boolean;
verifyAfterWrite: boolean;
rollbackOnFailure: boolean;
permissions?: number;
encoding: BufferEncoding;
retryAttempts: number;
retryDelay: number;
}
/**
* Configuration merge strategy
*/
type MergeStrategy = 'replace' | 'merge-deep' | 'merge-shallow' | 'merge-arrays' | 'custom';
/**
* Custom merge function
*/
type CustomMergeFunction = (existing: unknown, incoming: unknown, path: string[]) => unknown;
/**
* Safe configuration updater with atomic operations
*/
declare class ConfigSafeUpdater {
private options;
private activeTransactions;
private backupHistory;
constructor(options?: Partial<SafeUpdateOptions>);
/**
* Safely update configuration file with atomic operations
*/
updateConfig(filepath: string, updates: Partial<EnigmaConfig> | ((current: EnigmaConfig) => EnigmaConfig), mergeStrategy?: MergeStrategy, customMerge?: CustomMergeFunction): Promise<SafeUpdateResult>;
/**
* Batch update multiple configuration files
*/
batchUpdate(updates: Array<{
filepath: string;
updates: Partial<EnigmaConfig> | ((current: EnigmaConfig) => EnigmaConfig);
mergeStrategy?: MergeStrategy;
customMerge?: CustomMergeFunction;
}>): Promise<SafeUpdateResult[]>;
/**
* Rollback a configuration update by transaction ID
*/
rollbackByTransactionId(transactionId: string): Promise<boolean>;
/**
* Get list of available backups for a file
*/
getBackupHistory(filepath?: string): Array<{
timestamp: Date;
filepath: string;
backupPath: string;
}>;
/**
* Restore configuration from a backup
*/
restoreFromBackup(backupPath: string, targetPath?: string): Promise<SafeUpdateResult>;
/**
* Create a new transaction
*/
private createTransaction;
/**
* Load current configuration
*/
private loadCurrentConfig;
/**
* Apply updates to configuration
*/
private applyUpdates;
/**
* Deep merge two objects
*/
private deepMerge;
/**
* Merge with special array handling
*/
private mergeWithArrays;
/**
* Commit transaction with atomic write
*/
private commitTransaction;
/**
* Rollback transaction
*/
private rollbackTransaction;
/**
* Verify write operation
*/
private verifyWrite;
/**
* Clean up old backups
*/
private cleanupOldBackups;
/**
* Calculate changes between configurations
*/
private calculateChanges;
/**
* Get original path from backup filename
*/
private getOriginalPathFromBackup;
}
/**
* Factory function for creating safe updater
*/
declare function createConfigSafeUpdater(options?: Partial<SafeUpdateOptions>): ConfigSafeUpdater;
/**
* Copyright (c) 2025 Rowan Cardow
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* Configuration watcher events
*/
interface ConfigWatcherEvents {
'config-changed': (result: ConfigChangeResult) => void;
'config-validated': (result: ValidationResult$2) => void;
'config-error': (error: ConfigError) => void;
'file-added': (filepath: string) => void;
'file-removed': (filepath: string) => void;
'watcher-ready': () => void;
'watcher-error': (error: Error) => void;
}
/**
* Configuration change result
*/
interface ConfigChangeResult {
filepath: string;
timestamp: Date;
changeType: 'added' | 'changed' | 'removed';
isValid: boolean;
config?: EnigmaConfig;
validation?: ValidationResult$2;
error?: ConfigError;
previousConfig?: EnigmaConfig;
}
/**
* Configuration watcher options
*/
interface ConfigWatcherOptions {
enabled: boolean;
debounceMs: number;
ignoreInitial: boolean;
persistent: boolean;
followSymlinks: boolean;
ignorePermissionErrors: boolean;
atomic: boolean;
awaitWriteFinish: {
stabilityThreshold: number;
pollInterval: number;
};
watchPatterns: string[];
ignorePatterns: string[];
validateOnChange: boolean;
backupOnChange: boolean;
maxBackups: number;
}
/**
* Configuration file watcher
*/
declare class ConfigWatcher extends EventEmitter {
private options;
private watcher?;
private isWatching;
private watchedFiles;
private fileTrackers;
private currentConfig?;
private configHistory;
constructor(options?: Partial<ConfigWatcherOptions>);
/**
* Start watching configuration files
*/
start(watchPaths?: string[]): Promise<void>;
/**
* Stop watching configuration files
*/
stop(): Promise<void>;
/**
* Add a file or pattern to watch
*/
addWatch(path: string): void;
/**
* Remove a file or pattern from watching
*/
removeWatch(path: string): void;
/**
* Get currently watched files
*/
getWatchedFiles(): string[];
/**
* Get configuration change history
*/
getConfigHistory(): Array<{
timestamp: Date;
config: EnigmaConfig;
filepath: string;
}>;
/**
* Manually trigger validation of a configuration file
*/
validateFile(filepath: string): Promise<ValidationResult$2>;
/**
* Set up watcher event handlers
*/
private setupWatcherEvents;
/**
* Handle file change with debouncing
*/
private handleFileChange;
/**
* Process file change after debounce period
*/
private processFileChange;
/**
* Load configuration from file
*/
private loadConfigFile;
/**
* Add configuration to history
*/
private addToHistory;
/**
* Backup current configuration
*/
private backupConfiguration;
/**
* Check if a file is a configuration file
*/
private isConfigFile;
}
/**
* Factory function for creating configuration watcher
*/
declare function createConfigWatcher(options?: Partial<ConfigWatcherOptions>): ConfigWatcher;
/**
* Convenience function for watching a specific configuration file
*/
declare function watchConfigFile(filepath: string, options?: Partial<ConfigWatcherOptions>): Promise<ConfigWatcher>;
/**
* Configuration schema using Zod for validation
* Defines all possible configuration options for Tailwind Enigma
*/
declare const EnigmaConfigSchema: z.ZodObject<{
pretty: z.ZodDefault<z.ZodBoolean>;
input: z.ZodDefault<z.ZodString>;
output: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodObject<{
format: z.ZodDefault<z.ZodString>;
filename: z.ZodDefault<z.ZodString>;
preserveOriginal: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
format: string;
filename: string;
preserveOriginal: boolean;
}, {
format?: string | undefined;
filename?: string | undefined;
preserveOriginal?: boolean | undefined;
}>]>>;
minify: z.ZodDefault<z.ZodBoolean>;
removeUnused: z.ZodDefault<z.ZodBoolean>;
verbose: z.ZodDefault<z.ZodBoolean>;
veryVerbose: z.ZodDefault<z.ZodBoolean>;
quiet: z.ZodDefault<z.ZodBoolean>;
debug: z.ZodDefault<z.ZodBoolean>;
logLevel: z.ZodOptional<z.ZodEnum<["trace", "debug", "info", "warn", "error", "fatal"]>>;
logFile: z.ZodOptional<z.ZodString>;
logFormat: z.ZodOptional<z.ZodEnum<["human", "json", "csv"]>>;
maxConcurrency: z.ZodDefault<z.ZodNumber>;
classPrefix: z.ZodDefault<z.ZodString>;
excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
followSymlinks: z.ZodDefault<z.ZodBoolean>;
maxFiles: z.ZodOptional<z.ZodNumber>;
includeFileTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["HTML", "JAVASCRIPT", "CSS", "TEMPLATE"]>, "many">>;
excludeExtensions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
preserveComments: z.ZodDefault<z.ZodBoolean>;
sourceMaps: z.ZodDefault<z.ZodBoolean>;
dev: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
watch: z.ZodDefault<z.ZodBoolean>;
server: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
port: z.ZodDefault<z.ZodNumber>;
host: z.ZodDefault<z.ZodString>;
open: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
open: boolean;
enabled: boolean;
port: number;
host: string;
}, {
open?: boolean | undefined;
enabled?: boolean | undefined;
port?: number | undefined;
host?: string | undefined;
}>>;
diagnostics: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
performance: z.ZodDefault<z.ZodBoolean>;
memory: z.ZodDefault<z.ZodBoolean>;
fileWatcher: z.ZodDefault<z.ZodBoolean>;
classAnalysis: z.ZodDefault<z.ZodBoolean>;
thresholds: z.ZodDefault<z.ZodObject<{
memoryWarning: z.ZodDefault<z.ZodNumber>;
memoryError: z.ZodDefault<z.ZodNumber>;
cpuWarning: z.ZodDefault<z.ZodNumber>;
cpuError: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
memoryWarning: number;
memoryError: number;
cpuWarning: number;
cpuError: number;
}, {
memoryWarning?: number | undefined;
memoryError?: number | undefined;
cpuWarning?: number | undefined;
cpuError?: number | undefined;
}>>;
}, "strip", z.ZodTypeAny, {
memory: boolean;
enabled: boolean;
performance: boolean;
fileWatcher: boolean;
classAnalysis: boolean;
thresholds: {
memoryWarning: number;
memoryError: number;
cpuWarning: number;
cpuError: number;
};
}, {
memory?: boolean | undefined;
enabled?: boolean | undefined;
performance?: boolean | undefined;
fileWatcher?: boolean | undefined;
classAnalysis?: boolean | undefined;
thresholds?: {
memoryWarning?: number | undefined;
memoryError?: number | undefined;
cpuWarning?: number | undefined;
cpuError?: number | undefined;
} | undefined;
}>>;
preview: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
autoRefresh: z.ZodDefault<z.ZodBoolean>;
showDiff: z.ZodDefault<z.ZodBoolean>;
highlightChanges: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
autoRefresh: boolean;
showDiff: boolean;
highlightChanges: boolean;
}, {
enabled?: boolean | undefined;
autoRefresh?: boolean | undefined;
showDiff?: boolean | undefined;
highlightChanges?: boolean | undefined;
}>>;
dashboard: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
port: z.ZodDefault<z.ZodNumber>;
host: z.ZodDefault<z.ZodString>;
updateInterval: z.ZodDefault<z.ZodNumber>;
showMetrics: z.ZodDefault<z.ZodBoolean>;
showLogs: z.ZodDefault<z.ZodBoolean>;
maxLogEntries: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
port: number;
host: string;
updateInterval: number;
showMetrics: boolean;
showLogs: boolean;
maxLogEntries: number;
}, {
enabled?: boolean | undefined;
port?: number | undefined;
host?: string | undefined;
updateInterval?: number | undefined;
showMetrics?: boolean | undefined;
showLogs?: boolean | undefined;
maxLogEntries?: number | undefined;
}>>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
watch: boolean;
server: {
open: boolean;
enabled: boolean;
port: number;
host: string;
};
diagnostics: {
memory: boolean;
enabled: boolean;
performance: boolean;
fileWatcher: boolean;
classAnalysis: boolean;
thresholds: {
memoryWarning: number;
memoryError: number;
cpuWarning: number;
cpuError: number;
};
};
preview: {
enabled: boolean;
autoRefresh: boolean;
showDiff: boolean;
highlightChanges: boolean;
};
dashboard: {
enabled: boolean;
port: number;
host: string;
updateInterval: number;
showMetrics: boolean;
showLogs: boolean;
maxLogEntries: number;
};
}, {
enabled?: boolean | undefined;
watch?: boolean | undefined;
server?: {
open?: boolean | undefined;
enabled?: boolean | undefined;
port?: number | undefined;
host?: string | undefined;
} | undefined;
diagnostics?: {
memory?: boolean | undefined;
enabled?: boolean | undefined;
performance?: boolean | undefined;
fileWatcher?: boolean | undefined;
classAnalysis?: boolean | undefined;
thresholds?: {
memoryWarning?: number | undefined;
memoryError?: number | undefined;
cpuWarning?: number | undefined;
cpuError?: number | undefined;
} | undefined;
} | undefined;
preview?: {
enabled?: boolean | undefined;
autoRefresh?: boolean | undefined;
showDiff?: boolean | undefined;
highlightChanges?: boolean | undefined;
} | undefined;
dashboard?: {
enabled?: boolean | undefined;
port?: number | undefined;
host?: string | undefined;
updateInterval?: number | undefined;
showMetrics?: boolean | undefined;
showLogs?: boolean | undefined;
maxLogEntries?: number | undefined;
} | undefined;
}>>;
htmlExtractor: z.ZodOptional<z.ZodObject<{
preserveWhitespace: z.ZodDefault<z.ZodBoolean>;
caseSensitive: z.ZodDefault<z.ZodBoolean>;
ignoreEmpty: z.ZodDefault<z.ZodBoolean>;
maxFileSize: z.ZodDefault<z.ZodNumber>;
timeout: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
timeout: number;
preserveWhitespace: boolean;
caseSensitive: boolean;
ignoreEmpty: boolean;
maxFileSize: number;
}, {
timeout?: number | undefined;
preserveWhitespace?: boolean | undefined;
caseSensitive?: boolean | undefined;
ignoreEmpty?: boolean | undefined;
maxFileSize?: number | undefined;
}>>;
jsExtractor: z.ZodOptional<z.ZodObject<{
enableFrameworkDetection: z.ZodDefault<z.ZodBoolean>;
includeDynamicClasses: z.ZodDefault<z.ZodBoolean>;
caseSensitive: z.ZodDefault<z.ZodBoolean>;
ignoreEmpty: z.ZodDefault<z.ZodBoolean>;
maxFileSize: z.ZodDefault<z.ZodNumber>;
timeout: z.ZodDefault<z.ZodNumber>;
supportedFrameworks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
timeout: number;
caseSensitive: boolean;
ignoreEmpty: boolean;
maxFileSize: number;
enableFrameworkDetection: boolean;
includeDynamicClasses: boolean;
supportedFrameworks: string[];
}, {
timeout?: number | undefined;
caseSensitive?: boolean | undefined;
ignoreEmpty?: boolean | undefined;
maxFileSize?: number | undefined;
enableFrameworkDetection?: boolean | undefined;
includeDynamicClasses?: boolean | undefined;
supportedFrameworks?: string[] | undefined;
}>>;
cssInjector: z.ZodOptional<z.ZodObject<{
cssPath: z.ZodString;
htmlPath: z.ZodString;
basePath: z.ZodOptional<z.ZodString>;
useRelativePaths: z.ZodDefault<z.ZodBoolean>;
linkAttributes: z.ZodDefault<z.ZodObject<{
rel: z.ZodDefault<z.ZodString>;
type: z.ZodDefault<z.ZodString>;
media: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
type: string;
rel: string;
media?: string | undefined;
}, {
type?: string | undefined;
rel?: string | undefined;
media?: string | undefined;
}>>;
insertPosition: z.ZodDefault<z.ZodEnum<["first", "last", "before-existing", "after-meta"]>>;
preserveFormatting: z.ZodDefault<z.ZodBoolean>;
preventDuplicates: z.ZodDefault<z.ZodBoolean>;
duplicateStrategy: z.ZodDefault<z.ZodEnum<["skip", "replace", "error"]>>;
createHeadIfMissing: z.ZodDefault<z.ZodBoolean>;
createBackup: z.ZodDefault<z.ZodBoolean>;
maxFileSize: z.ZodDefault<z.ZodNumber>;
timeout: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
timeout: number;
maxFileSize: number;
cssPath: string;
htmlPath: string;
useRelativePaths: boolean;
linkAttributes: {
type: string;
rel: string;
media?: string | undefined;
};
insertPosition: "first" | "last" | "before-existing" | "after-meta";
preserveFormatting: boolean;
preventDuplicates: boolean;
duplicateStrategy: "error" | "skip" | "replace";
createHeadIfMissing: boolean;
createBackup: boolean;
basePath?: string | undefined;
}, {
cssPath: string;
htmlPath: string;
timeout?: number | undefined;
maxFileSize?: number | undefined;
basePath?: string | undefined;
useRelativePaths?: boolean | undefined;
linkAttributes?: {
type?: string | undefined;
rel?: string | undefined;
media?: string | undefined;
} | undefined;
insertPosition?: "first" | "last" | "before-existing" | "after-meta" | undefined;
preserveFormatting?: boolean | undefined;
preventDuplicates?: boolean | undefined;
duplicateStrategy?: "error" | "skip" | "replace" | undefined;
createHeadIfMissing?: boolean | undefined;
createBackup?: boolean | undefined;
}>>;
fileIntegrity: z.ZodOptional<z.ZodObject<{
algorithm: z.ZodDefault<z.ZodEnum<["md5", "sha1", "sha256", "sha512"]>>;
createBackups: z.ZodDefault<z.ZodBoolean>;
backupDirectory: z.ZodDefault<z.ZodString>;
backupRetentionDays: z.ZodDefault<z.ZodNumber>;
maxFileSize: z.ZodDefault<z.ZodNumber>;
timeout: z.ZodDefault<z.ZodNumber>;
verifyAfterRollback: z.ZodDefault<z.ZodBoolean>;
batchSize: z.ZodDefault<z.ZodNumber>;
enableCaching: z.ZodDefault<z.ZodBoolean>;
cacheSize: z.ZodDefault<z.ZodNumber>;
enableCompression: z.ZodDefault<z.ZodBoolean>;
compressionAlgorithm: z.ZodDefault<z.ZodEnum<["gzip", "deflate", "brotli"]>>;
compressionLevel: z.ZodDefault<z.ZodNumber>;
compressionThreshold: z.ZodDefault<z.ZodNumber>;
enableDeduplication: z.ZodDefault<z.ZodBoolean>;
deduplicationDirectory: z.ZodDefault<z.ZodString>;
deduplicationAlgorithm: z.ZodDefault<z.ZodEnum<["md5", "sha1", "sha256", "sha512"]>>;
deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
useHardLinks: z.ZodDefault<z.ZodBoolean>;
enableIncrementalBackup: z.ZodDefault<z.ZodBoolean>;
backupStrategy: z.ZodDefault<z.ZodEnum<["full", "incremental", "auto"]>>;
changeDetectionMethod: z.ZodDefault<z.ZodEnum<["mtime", "checksum", "hybrid"]>>;
maxIncrementalChain: z.ZodDefault<z.ZodNumber>;
fullBackupInterval: z.ZodDefault<z.ZodNumber>;
incrementalDirectory: z.ZodDefault<z.ZodString>;
enableDifferentialBackup: z.ZodDefault<z.ZodBoolean>;
differentialStrategy: z.ZodDefault<z.ZodEnum<["auto", "manual", "threshold-based"]>>;
differentialFullBackupThreshold: z.ZodDefault<z.ZodNumber>;
differentialFullBackupInterval: z.ZodDefault<z.ZodNumber>;
differentialDirectory: z.ZodDefault<z.ZodString>;
differentialSizeMultiplier: z.ZodDefault<z.ZodNumber>;
enableBatchProcessing: z.ZodDefault<z.ZodBoolean>;
minBatchSize: z.ZodDefault<z.ZodNumber>;
maxBatchSize: z.ZodDefault<z.ZodNumber>;
dynamicBatchSizing: z.ZodDefault<z.ZodBoolean>;
memoryThreshold: z.ZodDefault<z.ZodNumber>;
cpuThreshold: z.ZodDefault<z.ZodNumber>;
eventLoopLagThreshold: z.ZodDefault<z.ZodNumber>;
batchProcessingStrategy: z.ZodDefault<z.ZodEnum<["sequential", "parallel", "adaptive"]>>;
enableProgressTracking: z.ZodDefault<z.ZodBoolean>;
progressUpdateInterval: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enableProgressTracking: boolean;
timeout: number;
algorithm: "md5" | "sha1" | "sha256" | "sha512";
maxFileSize: number;
createBackups: boolean;
backupDirectory: string;
backupRetentionDays: number;
verifyAfterRollback: boolean;
batchSize: number;
enableCaching: boolean;
cacheSize: number;
enableCompression: boolean;
compressionAlgorithm: "gzip" | "deflate" | "brotli";
compressionLevel: number;
compressionThreshold: number;
enableDeduplication: boolean;
deduplicationDirectory: string;
deduplicationAlgorithm: "md5" | "sha1" | "sha256" | "sha512";
deduplicationThreshold: number;
useHardLinks: boolean;
enableIncrementalBackup: boolean;
backupStrategy: "full" | "incremental" | "auto";
changeDetectionMethod: "mtime" | "checksum" | "hybrid";
maxIncrementalChain: number;
fullBackupInterval: number;
incrementalDirectory: string;
enableDifferentialBackup: boolean;
differentialStrategy: "auto" | "manual" | "threshold-based";
differentialFullBackupThreshold: number;
differentialFullBackupInterval: number;
differentialDirectory: string;
differentialSizeMultiplier: number;
enableBatchProcessing: boolean;
minBatchSize: number;
maxBatchSize: number;
dynamicBatchSizing: boolean;
memoryThreshold: number;
cpuThreshold: number;
eventLoopLagThreshold: number;
batchProcessingStrategy: "sequential" | "parallel" | "adaptive";
progressUpdateInterval: number;
}, {
enableProgressTracking?: boolean | undefined;
timeout?: number | undefined;
algorithm?: "md5" | "sha1" | "sha256" | "sha512" | undefined;
maxFileSize?: number | undefined;
createBackups?: boolean | undefined;
backupDirectory?: string | undefined;
backupRetentionDays?: number | undefined;
verifyAfterRollback?: boolean | undefined;
batchSize?: number | undefined;
enableCaching?: boolean | undefined;
cacheSize?: number | undefined;
enableCompression?: boolean | undefined;
compressionAlgorithm?: "gzip" | "deflate" | "brotli" | undefined;
compressionLevel?: number | undefined;
compressionThreshold?: number | undefined;
enableDeduplication?: boolean | undefined;
deduplicationDirectory?: string | undefined;
deduplicationAlgorithm?: "md5" | "sha1" | "sha256" | "sha512" | undefined;
deduplicationThreshold?: number | undefined;
useHardLinks?: boolean | undefined;
enableIncrementalBackup?: boolean | undefined;
backupStrategy?: "full" | "incremental" | "auto" | undefined;
changeDetectionMethod?: "mtime" | "checksum" | "hybrid" | undefined;
maxIncrementalChain?: number | undefined;
fullBackupInterval?: number | undefined;
incrementalDirectory?: string | undefined;
enableDifferentialBackup?: boolean | undefined;
differentialStrategy?: "auto" | "manual" | "threshold-based" | undefined;
differentialFullBackupThreshold?: number | undefined;
differentialFullBackupInterval?: number | undefined;
differentialDirectory?: string | undefined;
differentialSizeMultiplier?: number | undefined;
enableBatchProcessing?: boolean | undefined;
minBatchSize?: number | undefined;
maxBatchSize?: number | undefined;
dynamicBatchSizing?: boolean | undefined;
memoryThreshold?: number | undefined;
cpuThreshold?: number | undefined;
eventLoopLagThreshold?: number | undefined;
batchProcessingStrategy?: "sequential" | "parallel" | "adaptive" | undefined;
progressUpdateInterval?: number | undefined;
}>>;
patternValidator: z.ZodOptional<z.ZodObject<{
enableValidation: z.ZodDefault<z.ZodBoolean>;
skipInvalidClasses: z.ZodDefault<z.ZodBoolean>;
warnOnInvalidClasses: z.ZodDefault<z.ZodBoolean>;
customClasses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
enableValidation: boolean;
skipInvalidClasses: boolean;
warnOnInvalidClasses: boolean;
customClasses: string[];
}, {
enableValidation?: boolean | undefined;
skipInvalidClasses?: boolean | undefined;
warnOnInvalidClasses?: boolean | undefined;
customClasses?: string[] | undefined;
}>>;
validation: z.ZodDefault<z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
validateOnLoad: z.ZodDefault<z.ZodBoolean>;
validateOnChange: z.ZodDefault<z.ZodBoolean>;
strictMode: z.ZodDefault<z.ZodBoolean>;
warnOnDeprecated: z.ZodDefault<z.ZodBoolean>;
failOnInvalid: z.ZodDefault<z.ZodBoolean>;
crossFieldValidation: z.ZodDefault<z.ZodBoolean>;
securityValidation: z.ZodDefault<z.ZodBoolean>;
performanceValidation: z.ZodDefault<z.ZodBoolean>;
customRules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
validateOnLoad: boolean;
validateOnChange: boolean;
strictMode: boolean;
warnOnDeprecated: boolean;
failOnInvalid: boolean;
crossFieldValidation: boolean;
securityValidation: boolean;
performanceValidation: boolean;
customRules: string[];
}, {
enabled?: boolean | und