Reporter

import { Reporter } from "@parcel/plugin";

export default new Reporter({
  buildSuccess({ bundleGraph, buildTime }) {
    let bundles = bundleGraph.getBundles();
    console.log(`✨ Built ${bundles.length} bundles in ${buildTime}ms!`);
  },
});

use parcel_plugin::{BuildSuccess, Diagnostic, Options, Plugin, register_plugin};

struct MyReporter;

impl Plugin for MyReporter {
  fn new(_config: &[u8]) -> Result<Self, Diagnostic> {
    Ok(MyReporter)
  }

  fn build_success(&self, event: &BuildSuccess, _options: &Options) -> Result<(), Diagnostic> {
    let bundles = event.bundle_graph.bundle_count();
    println!("✨ Built {} bundles in {:?}!", bundles, event.build_time);
    Ok(())
  }
}

register_plugin!(MyReporter);

package main

import (
	"fmt"

	parcel "github.com/parcel-bundler/parcel/plugin-go/v3"
)

type MyReporter struct{}

func (r *MyReporter) BuildSuccess(event *parcel.BuildSuccess, _ *parcel.Options) error {
	bundles := event.BundleGraph.BundleCount()
	fmt.Printf("✨ Built %d bundles in %v!\n", bundles, event.BuildTime)
	return nil
}

func init() {
	parcel.RegisterPlugin(func(config []byte) (any, error) {
		return &MyReporter{}, nil
	})
}

func main() {}

import ParcelPlugin

struct MyReporter: Reporter {
  init(config: NoConfig) {}

  func buildSuccess(_ event: BuildSuccess, options: Options) async throws {
    let bundles = event.bundleGraph.bundleCount
    print("✨ Built \(bundles) bundles in \(event.buildTime)!")
  }
}

#parcelPlugin(MyReporter.self)

import { Reporter } from "@parcel/plugin";

export default new Reporter({
  buildStart() {
    console.log("Started build!");
  },
});

impl Plugin for MyReporter {
  fn build_start(&self, _options: &Options) -> Result<(), Diagnostic> {
    println!("Started build!");
    Ok(())
  }
}

func (r *MyReporter) BuildStart(_ *parcel.Options) error {
	fmt.Println("Started build!")
	return nil
}

struct MyReporter: Reporter {
  func buildStart(options: Options) async throws {
    print("Started build!")
  }
}

import { Reporter } from "@parcel/plugin";

export default new Reporter({
  buildSuccess({ changedAssets, buildTime }) {
    console.log(`✨ Rebuilt ${changedAssets.length} assets in ${buildTime}ms!`);
  },
});

impl Plugin for MyReporter {
  fn build_success(&self, event: &BuildSuccess, _options: &Options) -> Result<(), Diagnostic> {
    println!("✨ Rebuilt {} assets in {:?}!", event.changed_assets.len(), event.build_time);
    Ok(())
  }
}

func (r *MyReporter) BuildSuccess(event *parcel.BuildSuccess, _ *parcel.Options) error {
	fmt.Printf("✨ Rebuilt %d assets in %v!\n", len(event.ChangedAssets), event.BuildTime)
	return nil
}

struct MyReporter: Reporter {
  func buildSuccess(_ event: BuildSuccess, options: Options) async throws {
    print("✨ Rebuilt \(event.changedAssets.count) assets in \(event.buildTime)!")
  }
}

import { Reporter } from "@parcel/plugin";

export default new Reporter({
  buildFailure({ diagnostics }) {
    console.log(`🚨 Build failed with ${diagnostics.length} errors.`);
  },
});

impl Plugin for MyReporter {
  fn build_failure(&self, event: &BuildFailure, _options: &Options) -> Result<(), Diagnostic> {
    println!("🚨 Build failed with {} errors.", event.diagnostics.len());
    Ok(())
  }
}

func (r *MyReporter) BuildFailure(event *parcel.BuildFailure, _ *parcel.Options) error {
	fmt.Printf("🚨 Build failed with %d errors.\n", event.Diagnostics.Len())
	return nil
}

struct MyReporter: Reporter {
  func buildFailure(_ event: BuildFailure, options: Options) async throws {
    print("🚨 Build failed with \(event.diagnostics.count) errors.")
  }
}

import { Reporter } from "@parcel/plugin";

export default new Reporter({
  log({ level, message, diagnostics }) {
    let messages =
      message != null ? [message] : diagnostics.map((d) => d.message);

    for (let message of messages) {
      sendToLogService(level, message);
    }
  },
});

impl Plugin for MyReporter {
  fn log(&self, event: &Log, _options: &Options) -> Result<(), Diagnostic> {
    let messages: Vec<String> = match event.message {
      Some(message) => vec![message.to_string()],
      None => event.diagnostics.iter().flat_map(|d| d.iter()).map(|d| d.message()).collect(),
    };

    for message in messages {
      send_to_log_service(event.level, &message);
    }
    Ok(())
  }
}

func (r *MyReporter) Log(event *parcel.Log, _ *parcel.Options) error {
	var messages []string
	if event.Diagnostics == nil {
		messages = []string{event.Message}
	} else {
		for _, d := range event.Diagnostics.All() {
			messages = append(messages, d.Message())
		}
	}

	for _, message := range messages {
		sendToLogService(event.Level, message)
	}
	return nil
}

struct MyReporter: Reporter {
  func log(_ event: Log, options: Options) async throws {
    let messages: [String]
    switch event.message {
    case .text(let message):
      messages = [message]
    case .diagnostics(let diagnostics):
      messages = diagnostics.map(\.message)
    @unknown default:
      messages = []
    }

    for message in messages {
      sendToLogService(event.level, message)
    }
  }
}