watch static method

Implementation

static Future<ReloadFileWatcher> watch({
  required ReloadController controller,
  required Iterable<String> roots,
  ReloadMode mode = ReloadMode.reload,
  Duration debounce = const Duration(milliseconds: 150),
  bool recursive = true,
  bool ignoreHidden = true,
  Iterable<String> extensions = const <String>[],
}) async {
  final normalizedRoots = roots
      .map((root) => Directory(root).absolute.path)
      .toSet()
      .toList()
    ..sort();

  if (normalizedRoots.isEmpty) {
    throw ArgumentError.value(roots, 'roots', 'At least one watch root is required.');
  }

  final normalizedExtensions = extensions
      .map((extension) => extension.trim().toLowerCase())
      .where((extension) => extension.isNotEmpty)
      .map((extension) => extension.startsWith('.') ? extension : '.$extension')
      .toSet();

  final subscriptions = <StreamSubscription<FileSystemEvent>>[];
  final watcher = ReloadFileWatcher._(
    controller: controller,
    mode: mode,
    debounce: debounce,
    recursive: recursive,
    ignoreHidden: ignoreHidden,
    extensions: normalizedExtensions,
    roots: normalizedRoots,
    subscriptions: subscriptions,
  );

  for (final root in normalizedRoots) {
    final directory = Directory(root);
    if (!await directory.exists()) {
      throw ArgumentError.value(root, 'roots', 'Watch root does not exist.');
    }
    subscriptions.add(
      directory.watch(recursive: recursive).listen(
        watcher._handleEvent,
        cancelOnError: false,
      ),
    );
  }

  return watcher;
}