Enum FileWatcherState 

pub enum FileWatcherState {
    Idle,
    Watching {
        paths: Vec<PathBuf>,
    },
    Failed {
        error: String,
    },
}

Runtime state of the file watcher

State Machine

    ┌─────┐
    │ Idle │
    └──┬──┘
       │ watch() succeeds
       ▼
   ┌─────────┐
   │ Watching │
   └────┬────┘
        │ fatal error
        ▼
   ┌─────────┐
   │ Failed  │────┐
   └─────────┘    │
        │          │ recover (unwatch + re-watch)
        │          └─────────────────────┐
        ▼                                ▼
   (exit application)                ┌─────┐
                                    │ Idle │
                                    └─────┘

States

• Idle: Initial state after FileWatcher::new(). The watcher is created but not watching any paths yet.

• Watching: Active state after successful watch() call. The watcher monitors the configured paths and emits file change events.

• Failed: Error state if watcher initialization fails. This is typically due to OS limitations (e.g., reached maximum file descriptor limit). Recovery requires creating a new FileWatcher instance.

Example

use dampen_dev::watcher::{FileWatcher, FileWatcherConfig};
use std::path::PathBuf;

let config = FileWatcherConfig::default();
let mut watcher = FileWatcher::new(config).expect("Failed to create watcher");
// State is now Idle

let path = PathBuf::from("src/ui");
watcher.watch(path).expect("Failed to watch");
// State is now Watching

// If fatal error occurs, state becomes Failed
// Recovery requires creating new watcher

Variants

Idle

Watcher is initialized but not started

Watching

Actively watching for changes

Fields

paths: Vec<PathBuf>

Paths being watched

Failed

Error state (watcher failed to initialize)

Fields

error: String

Error description

Trait Implementations

impl Debug for FileWatcherState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.