jetleaf_core library Core

🌱 JetLeaf Core

The central library providing foundational infrastructure for JetLeaf applications. It aggregates key modules for:

Dependency injection and application context management
Method interception and cross-cutting concerns
Internationalization (i18n) and message management
Core utilities and base abstractions
Declarative configuration via annotations

By importing this library, developers gain access to all core functionalities required to build modular, maintainable, and extensible JetLeaf applications.

🔑 Included Modules

🏷 Annotations

Provides lifecycle, dependency injection, configuration, conditional, pod/scoping, stereotype, and interception annotations.

annotation.dart

🏛 Application Context

Core abstractions, context lifecycle, pod registration, event management, and environment support.

context.dart

🔄 Interception

Method-level interception support for cross-cutting concerns.

intercept.dart

🌐 Messaging

Message source management, internationalization, and localization.

message.dart

⚡ Core Utilities

Base abstractions, utilities, and foundational components for building JetLeaf applications.

core.dart

🎯 Intended Usage

Import this library to access all core JetLeaf features:

import 'package:jetleaf_core/jetleaf_core.dart';

final context = GenericApplicationContext();
context.registerPod<MyService>();

class UserService with Interceptable {
  @LogExecution()
  void greet() => print('Hello!');
}

Provides a comprehensive foundation for IoC, AOP, i18n, lifecycle, and modular application architecture.

Classes

AbstractApplicationContext: The base implementation of a configurable Jetleaf Application Context.
AbstractExceptionDiagnoser<E extends Exception>: Base class for creating typed exception diagnosers that target a specific exception type E.
AbstractMessageSource: Base implementation of MessageSource providing common functionality.
AbstractMethodDispatcher: A foundational implementation of MethodInterceptorDispatcher and MethodInterceptor providing a unified interception pipeline for JetLeaf's runtime and AOP subsystems.
AfterInvocationInterceptor: Defines an interceptor that executes after method completion, regardless of whether the invocation succeeded or failed.
AfterReturningInterceptor: An interceptor that executes after a method successfully returns a value, without throwing an exception.
AfterThrowingInterceptor: An interceptor triggered when a target method throws an exception.
AnnotatedScopeMetadataResolver: A Jetleaf-provided implementation of ScopeMetadataResolver that determines scope metadata based on the presence of the @Scope annotation.
AnnotationAwareOrderComparator: A Jetleaf-provided OrderComparator implementation that determines ordering based on the presence of the @Order annotation or the Ordered interface.
AnnotationConfigApplicationContext: ApplicationContext implementation that supports annotation-based configuration.
AnnotationConfigRegistry: Annotation-Based Configuration Registry
AnnotationTypeFilter: A TypeFilter that matches classes based on the presence of specific annotations.
ApplicationAnnotatedLifecycleProcessor: Processor for application lifecycle annotations that discovers and invokes methods annotated with @OnApplicationStopping and @OnApplicationStopped.
ApplicationAvailability: Defines the contract for accessing and tracking an application's availability information, including both its liveness and readiness states.
ApplicationAvailabilityAutoConfiguration: Provides the default auto-configuration for managing and tracking application availability states—including both liveness and readiness.
ApplicationContext: The central interface for a JetLeaf application context.
ApplicationContextAware: 🫘 Interface for components that need access to the ApplicationContext.
ApplicationContextEvent: A base class for all events that are published within the context of an ApplicationContext.
ApplicationContextInitializer<T extends ConfigurableApplicationContext>: Strategy interface for initializing an ApplicationContext before it is refreshed.
ApplicationConversionService: A JetLeaf-managed, application-wide conversion service responsible for managing and coordinating all registered type converters.
ApplicationDiagnostics: High-level diagnostics orchestrator combining both:
ApplicationEnvironment: A concrete environment for standard JetLeaf applications.
ApplicationEvent: A base class for application-specific events within the JetLeaf framework.
ApplicationEventBus: Defines the contract for an event multicaster that manages the registration, removal, and dispatching of ApplicationEvents to ApplicationListeners.
ApplicationEventBusAware: 🫘 Interface for components that need access to the ApplicationEventBus.
ApplicationEventListener<E extends ApplicationEvent>: A listener for a specific type of ApplicationEvent.
ApplicationEventMethodAdapter: An adapter class in Jetleaf that bridges ApplicationEvents with listener methods.
ApplicationModule: An interface in Jetleaf that defines a configurable application module.
AroundMethodInterceptor: A comprehensive interceptor that wraps the entire method invocation process, allowing developers to control when and how the target method executes.
AssignableTypeFilter: A TypeFilter that matches classes assignable to a specific target type.
AutoConfiguration: Declares a class as a source of automatic configuration.
Autowired: Autowired annotation for dependency injection
AutowiredIgnore: An annotation used to mark a field as ignored by the dependency injection container.
AvailabilityEvent<Available extends AvailabilityState>: Represents an application-level event that conveys a change or report regarding an application's availability state.
AvailabilityState: A marker interface representing any application availability state.
Cleanup: Marks a method to be invoked after a pod is destroyed.
CompletedInitializationEvent: Event published when the ApplicationContext has completed its initialization phase.
Component: Component annotation for generic Jet components
ComponentScan: Annotation for Jetleaf component scanning.
ComponentScanFilter: Represents a filter definition for component scanning.
Condition: The base interface for all JetLeaf condition evaluators.
Conditional: An annotation that conditionally enables or disables JetLeaf-managed constructs such as Component, Pod, or configuration classes based on one or more declarative Condition evaluators.
ConditionalContext: Represents the conditional evaluation context in JetLeaf applications.
ConditionalOnAsset: An annotation that conditionally activates a Component, Pod, or configuration class based on the presence of a specific asset in the application's resources.
ConditionalOnClass: An annotation that conditionally activates a Component, Pod, or configuration class only if specific classes are present in the Dart runtime or compilation environment.
ConditionalOnDart: An annotation that conditionally activates a Component, Pod, or configuration class based on the current Dart SDK version.
ConditionalOnExpression: An annotation that conditionally activates a Component, Pod, or configuration class based on the evaluation of a custom expression.
ConditionalOnMissingClass: An annotation that conditionally activates a Component, Pod, or configuration class only if certain classes are absent from the Dart runtime or compilation environment.
ConditionalOnMissingPod: An annotation that activates a component only when specific pods are absent from the ConditionalContext.
ConditionalOnPod: An annotation that conditionally activates a Component, Pod, or configuration class based on the presence of other pods within the current ConditionalContext.
ConditionalOnProfile: An annotation that conditionally activates a Component, Pod, or configuration class based on the currently active profiles in the ConditionalContext.
ConditionalOnProperty: An annotation that conditionally enables a Component, Pod, or configuration class based on the value(s) of one or more properties.
ConditionEvaluator: The ConditionEvaluator in Jetleaf is responsible for evaluating conditional annotations (e.g., Conditional, ConditionalOnClass, ConditionalOnPod) and determining whether a given source (class, method, or configuration) should be included in the Jetleaf application context.
ConfigurableApplicationContext: A specialized ApplicationContext that allows for full configuration and lifecycle management.
ConfigurableMessageSource: Main implementation of MessageSource that supports loading messages from multiple resources and formats.
Configuration: Configuration annotation for configuration classes
ConfigurationProperty: Annotation used to bind externalized configuration properties from the Environment into a Dart object.
ContextClosedEvent: Event published when an ApplicationContext is closed.
ContextFailedEvent: Event published when the ApplicationContext fails to start or refresh.
ContextReadyEvent: Event published when the ApplicationContext is ready.
ContextRestartedEvent: Event published when the ApplicationContext is restarted.
ContextSetupEvent: Event published when the ApplicationContext is refreshed or initialized.
ContextStartedEvent: Event published when the ApplicationContext is started or restarted.
ContextStoppedEvent: Event published when the ApplicationContext is explicitly stopped.
ConversionServiceAware: 🫘 Interface for components that need access to a ConversionService.
ConversionServiceConfigurer: A JetLeaf extension interface for programmatically configuring type conversion within the application’s ConversionService.
DefaultMethodInterceptor: Default implementation of MethodInterceptorRegistry and related intercept processing.
DependsOn: A Jetleaf annotation that declares explicit dependencies between pods.
Description: Provides a human-readable description of a class or method.
EntryApplicationAware: 🚀 Interface for components that need access to the entry application class.
EnvironmentAware: 🫘 Interface for components that can be configured with an Environment.
EventListener: Annotation to mark a method that should run when the application is listening to a specific type of ApplicationEvent.
EventObject: A base class for all framework-level events.
EventType<T extends ApplicationEvent>: 🫘 Represents a typed application event associated with a specific package.
ExceptionDiagnoser: Defines the contract for components capable of analyzing exceptions and producing structured diagnostic information.
ExceptionDiagnosis: Represents a structured diagnostic report for an exception, providing human-readable context, optional recommended actions, and the originating exception itself.
ExceptionDiagnosisReporter: Defines the contract for components responsible for handling and reporting structured exception diagnoses.
ExceptionReporter: Provides an abstraction for reporting, logging, or forwarding exceptions that occur within the application.
ExitCodeEvent: An ApplicationEvent that signals the application should exit with a specific exit code.
ExitCodeExceptionHandler: A strategy interface for mapping a specific Exception to a process exit code.
ExitCodeGenerator: Strategy interface for determining the exit code returned from a JetLeaf application or a process.
ExitCodeGenerators: A container and manager for multiple ExitCodeGenerator instances.
GenericApplicationContext: Generic ApplicationContext implementation that holds a single internal DefaultListablePodFactory instance and does not assume a specific pod definition format.
Import: The Import annotation in Jetleaf is used to import other configuration classes.
ImportClass: 🫘 Represents a logical import entry with qualification and enablement metadata.
ImportSelector: 🫘 A strategy interface for selecting which imports should be applied.
Interceptable: Provides runtime interception support for method invocations within JetLeaf-managed components.
InterceptorDependencyCycle: A DependencyCycle implementation that represents a circular dependency between method interceptors in the interceptor chain.
KeepAlive: A lifecycle-aware component that keeps the Dart VM alive as long as the ApplicationContext is running.
KeyValueOf<K, V>: KeyValueOf Annotation
Lazy: Indicates that a pod should be lazily initialized.
Lifecycle: A common interface defining methods for start/stop lifecycle control.
LifecycleProcessor: Defines a contract for components that participate in the application lifecycle.
LoggableExceptionDiagnosisReporter: An implementation of ExceptionDiagnosisReporter that outputs structured exception diagnosis information using the JetLeaf logging system.
MessageSource: Interface for resolving messages, with support for parameterization and internationalization.
MessageSourceAware: 🫘 Interface for components that need access to a MessageSource.
MessageSourceLoader: Interface for loading messages from different resource formats.
MethodBeforeInterceptor: Defines an interceptor that executes logic before the target method invocation begins.
MethodInterceptor: Defines the core interception contract for JetLeaf’s AOP (Aspect-Oriented Programming) framework, allowing runtime interception and augmentation of method invocations.
MethodInterceptorConfigurer: Strategy interface for configuring method interceptors in JetLeaf intercept.
MethodInterceptorDispatcher: Defines an advanced interception dispatcher that coordinates multiple method interceptors.
MethodInterceptorRegistry: Central registry for managing method-level interceptors and their dispatching.
MethodInvocation<T>: Represents a reflective method invocation within the interception pipeline.
Named: Explicitly specifies a name for a Pod (Dependency Injection component) that overrides all other naming mechanisms in the Jetleaf framework.
OnApplicationFailed: Annotation to mark a method that should run when the application fails to start or refresh.
OnApplicationReady: Annotation to mark a method that should run when the application is fully ready to serve requests.
OnApplicationStarted: Annotation to mark a method that should run when the application has started, meaning the context is refreshed but the app is not yet fully ready.
OnApplicationStarting: Annotation to mark a method that should run when the application is starting, before the context refresh occurs.
OnApplicationStopped: Annotation to mark a method that should run when the application has fully stopped.
OnApplicationStopping: Annotation to mark a method that should run when the application is stopping.
OnAssetCondition: A Condition implementation that determines whether an annotated component, configuration, or pod should be activated based on the presence of a specific asset within the application's resource path.
OnClassCondition: A Condition implementation that evaluates the presence or absence of classes in the current runtime to determine if a component, pod, or configuration should be activated.
OnContextLoaded: Annotation to mark a method that should run when the application context has been loaded, but before it is fully refreshed.
OnContextPrepared: Annotation to mark a method that should run when the application context has been prepared.
OnDartCondition: A Condition implementation that evaluates the current Dart SDK version to determine whether an annotated component, configuration, or pod should be activated.
OnEnvironmentPrepared: Annotation to mark a method that should run when the application environment has been prepared, but before the context is loaded.
OnExpressionCondition: A Condition implementation that dynamically evaluates an expression to determine whether a component, configuration, or pod should be activated.
OnPodCondition: A Condition implementation that evaluates the presence or absence of pods in the current ConditionalContext to determine whether a component, configuration, or definition should be activated.
OnProfileCondition: A Condition implementation that evaluates the application's currently active profiles to determine whether a component, configuration, or pod should be activated.
OnPropertyCondition: A Condition implementation that evaluates whether a component or pod should be activated based on the presence and value of properties in the current ConditionalContext.environment.
Order: Specifies the order of precedence for a class when processed by the framework or runtime system.
Phased: Interface for objects that may participate in a phased process such as lifecycle management.
Pod: Marks a method as a pod provider, enabling it to participate in the dependency injection (DI) lifecycle of the application.
PodFactoryAware: 🫘 Interface for components that need access to the PodFactory.
PodFactoryCustomizer<T extends ConfigurablePodFactory>: A lifecycle hook interface for customizing the PodFactory before it is fully initialized or configured within the JetLeaf framework.
PodFactoryPostProcessor: Factory hook that allows for custom modification of an application context's pod definitions, adapting the pod property values of the context's underlying pod factory.
PodNameAware: 🫘 Interface for components that need to know their assigned pod name.
PodPostProcessorManager: Manager for coordinating pod factory post-processors and pod-aware processors with proper ordering and lifecycle management.
PodRegistrar: A contract in JetLeaf for components that can register pods into the application’s dependency container.
PodRegistry: A contract in JetLeaf that provides methods for managing pods in the container.
PodSpec<T>: A concrete implementation of the `Spec` API in Jetleaf.
PodSpecContext: An implementation of `SpecContext` in Jetleaf that resolves dependencies during pod creation and supplier evaluation.
PostConstruct: Marks a method to be invoked after a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
PreConstruct: Marks a method to be invoked before a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
PreDestroy: Marks a method to be invoked before a pod is destroyed.
Primary: Primary annotation for marking a primary pod
Profile: Profile annotation for profile-specific pods
Qualifier: A Jetleaf annotation used to disambiguate injection targets when multiple candidate pods of the same type exist.
RegexPatternTypeFilter: A TypeFilter that matches classes based on regular expression patterns against class names.
RequiredAll: An annotation used for dependency injection that automatically injects all eligible fields into a class.
Resource<Key, Value>: A generic abstraction for JetLeaf-compatible resource.
Role: Declares the design role of a class or method within a Jetleaf application.
RunAfter: A reflective annotation that declares that the annotated interceptor, filter, or handler should execute after one or more specified targets within the JetLeaf request processing pipeline.
RunBefore: A reflective annotation that declares that the annotated interceptor, filter, or handler should execute before one or more specified targets within the JetLeaf request processing pipeline.
Scope: Annotation that specifies the scope of a pod within the JetLeaf container.
ScopeMetadataResolver: Strategy interface for resolving scope metadata for a given class in Jetleaf.
Service: Service annotation for service layer components
SimpleApplicationEventBus: A straightforward implementation of ApplicationEventBus that manages application event listeners.
SimpleMethodInvocation<T>: Represents a reflective invocation of a method on a target object, forming the core join point within JetLeaf’s interception system.
SmartLifecycle: An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order.
Spec<T>: A Jetleaf definition describing how a pod should be instantiated, configured, and managed inside the container.
SpecContext: A context object in Jetleaf provided to suppliers and pod definitions for resolving dependencies at runtime.
StartupEvent: An application–level event signaling that the JetLeaf application has completed its startup sequence.
TargetType<T>: TargetType Annotation
TypeFilter: Abstract base class for type filtering strategies used in component scanning.
Value: Value annotation for property injection
WhenConditional: The base class for all annotations that are eligible for conditional evaluation in the JetLeaf framework.

Enums

ApplicationType: Enumeration of types of applications that can be run in a JetLeaf environment.
FilterType: Enumeration of supported filter types for component scanning.
LivenessState: Represents the liveness state of an application.
ReadinessState: Represents the readiness state of an application.

Typedefs

AsyncMethodInvocator<T> = Future<T> Function(): Represents a deferred executable function that performs a method invocation.

Exceptions / Errors

MessageSourceException: An exception that occurs when resolving messages from a MessageSource.