Order.new constructor - Order - annotation library

Specifies the order of precedence for a class when processed by the framework or runtime system.

The @Order annotation provides deterministic ordering for components such as:

The lower the value, the higher the priority. That is, @Order(0) runs before @Order(1), and so on.

🔁 Execution Order Rules:

Ascending Order: Lower value means earlier execution.
If two components have the same @Order, their relative order is undefined unless explicitly handled by the framework.
Classes without @Order may be given a default priority, e.g., @Order(1000) or treated as "last".

@Order(1)
class FirstMiddleware {}

@Order(2)
class SecondMiddleware {}

@Order(0)
class HighestPriority {}

In this example, the order of invocation would be:

Use Case	Why `@Order` Helps
Middleware Chains	Defines filter/interceptor execution flow
Plugin Systems	Ensures predictable hook registration
Application Phases	Orders startup or shutdown hooks
Event Listeners	Prioritizes listeners in a dispatch tree

@Order must be placed on class declarations only.
Typically interpreted by the container, registry, or dispatcher at runtime or compile-time.
It is framework-agnostic, but effective only if the underlying system respects the ordering logic.

This annotation applies to classes only:

@Order(10)
class AuditLoggerInterceptor {}

Frameworks can use this annotation to sort registered components:

final List<Object> ordered = components
    .whereType<HasOrder>()
    .toList()
  ..sort((a, b) => a.order.compareTo(b.order));

Consider defining a common interface like HasOrder to extract the value:

abstract class HasOrder {
  int get order;
}