serveWatchedArtisanalAppOnSocket function

Implementation

Future<WatchedSocketArtisanalAppHost> serveWatchedArtisanalAppOnSocket({
  required ReloadWidgetBuilder homeBuilder,
  required Iterable<String> watchRoots,
  ReloadController? controller,
  ReloadMode watchMode = ReloadMode.reload,
  Duration watchDebounce = const Duration(milliseconds: 150),
  bool watchRecursive = true,
  bool watchIgnoreHidden = true,
  Iterable<String> watchExtensions = const <String>['.dart'],
  io.InternetAddress? address,
  int port = 2323,
  bool v6Only = false,
  bool shared = false,
  hosts.TerminalDimensions initialSize = const (width: 80, height: 24),
  bool supportsAnsi = true,
  ColorProfile colorProfile = ColorProfile.trueColor,
  String? title,
  Theme? theme,
  Theme? darkTheme,
  ThemeMode themeMode = ThemeMode.system,
  Theme Function()? themeBuilder,
  ImageAutoMode imageAutoMode = ImageAutoMode.sessionCapabilities,
  runtime.ProgramOptions? options,
}) async {
  final reloadController = controller ?? ReloadController();
  final ownsController = controller == null;
  final watcher = await ReloadFileWatcher.watch(
    controller: reloadController,
    roots: watchRoots,
    mode: watchMode,
    debounce: watchDebounce,
    recursive: watchRecursive,
    ignoreHidden: watchIgnoreHidden,
    extensions: watchExtensions,
  );

  try {
    final server = await serveReloadableArtisanalAppOnSocket(
      controller: reloadController,
      homeBuilder: homeBuilder,
      address: address,
      port: port,
      v6Only: v6Only,
      shared: shared,
      initialSize: initialSize,
      supportsAnsi: supportsAnsi,
      colorProfile: colorProfile,
      title: title,
      theme: theme,
      darkTheme: darkTheme,
      themeMode: themeMode,
      themeBuilder: themeBuilder,
      imageAutoMode: imageAutoMode,
      options: options,
    );

    return WatchedSocketArtisanalAppHost._(
      server: server,
      controller: reloadController,
      watcher: watcher,
      ownsController: ownsController,
    );
  } catch (_) {
    await watcher.dispose();
    if (ownsController) {
      await reloadController.dispose();
    }
    rethrow;
  }
}