assemblerjs 1.0.1 → 1.1.0

package/README.md

@@ -4,14 +4,14 @@ A modern, type-safe, and lightweight [Dependency Injection](https://en.wikipedia
 
 > ✨ **Universal Library**: Works seamlessly in Node.js, browsers, and any JavaScript environment that supports ES2020+
 
-![Statements](https://img.shields.io/badge/statements-91.01%25-brightgreen.svg?style=flat) ![Branches](https://img.shields.io/badge/branches-79.6%25-red.svg?style=flat) ![Functions](https://img.shields.io/badge/functions-87.62%25-yellow.svg?style=flat) ![Lines](https://img.shields.io/badge/lines-90.76%25-brightgreen.svg?style=flat)
+![Statements](https://img.shields.io/badge/statements-93.78%25-brightgreen.svg?style=flat) ![Branches](https://img.shields.io/badge/branches-83.87%25-yellow.svg?style=flat) ![Functions](https://img.shields.io/badge/functions-93.63%25-brightgreen.svg?style=flat) ![Lines](https://img.shields.io/badge/lines-93.96%25-brightgreen.svg?style=flat)
 
 ## Performance Metrics
 
-![Assembler Building](https://img.shields.io/badge/assembler%20building-156k%20ops%2Fsec-brightgreen.svg?style=flat)
-![Injectable Resolution](https://img.shields.io/badge/singleton%20cache-1.2M%20ops%2Fsec-brightgreen.svg?style=flat)
-![Event System](https://img.shields.io/badge/event%20emit-432k%20ops%2Fsec-brightgreen.svg?style=flat)
-![Decorators](https://img.shields.io/badge/decorators-890k%20ops%2Fsec-brightgreen.svg?style=flat)
+![assembler building](https://img.shields.io/badge/assembler%20building-11k%20ops%2Fsec-green.svg?style=flat)
+![singleton cache](https://img.shields.io/badge/singleton%20cache-104k%20ops%2Fsec-brightgreen.svg?style=flat)
+![event emit](https://img.shields.io/badge/event%20emit-558k%20ops%2Fsec-brightgreen.svg?style=flat)
+![decorators](https://img.shields.io/badge/decorators-588k%20ops%2Fsec-brightgreen.svg?style=flat)
 
 [→ Full Benchmarks](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/performance/benchmarks.md)
 
@@ -24,6 +24,7 @@ A modern, type-safe, and lightweight [Dependency Injection](https://en.wikipedia
 - 🌳 **Tree-Shakable** - Optimized bundle size (~5-6 KB for minimal usage)
 - ♻️ **Lifecycle Hooks** - `onRegister`, `onInit`, `onDispose`
 - 📡 **Built-in Event System** - Integrated EventManager
+- 🔀 **AOP/Transversals** - Cross-cutting concerns (logging, security, caching, performance)
 - 🎨 **Custom Decorators** - Easy creation with `ParameterDecoratorFactory` and `createConstructorDecorator`
 - 🔧 **Flexible Configuration** - Runtime configuration override
 - 🏷️ **Tags Support** - Group and retrieve dependencies by tags
@@ -114,11 +115,13 @@ Comprehensive documentation is available at:
 - [Dependency Injection](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/core-concepts/dependency-injection.md) - DI patterns
 - [Abstraction Pattern](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/core-concepts/abstraction-pattern.md) - Interface-based design
 - [Lifecycle Hooks](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/core-concepts/lifecycle-hooks.md) - Initialization & cleanup
+- [Transversals (AOP)](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/core-concepts/transversals-aop.md) - Aspect-Oriented Programming
 
 #### Decorators
 - [Parameter Decorators](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/decorators/parameter-decorators.md) - Built-in decorators
 - [Custom Parameter Decorators](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/decorators/custom-parameter.md) - Create your own
 - [Custom Class Decorators](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/decorators/custom-class.md) - Type-safe class decorators
+- [AOP Decorators](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/decorators/aop-decorators.md) - @Transversal, @Before, @After, @Around, @Affect
 
 #### Features
 - [Event System](https://github.com/benoitlahoz/assemblerjs/blob/main/docs/assemblerjs/features/events.md) - Event-driven architecture

package/dist/index.d.ts

@@ -108,6 +108,181 @@ export declare abstract class AbstractListenerCollection {
     abstract [Symbol.iterator](): Iterator<EventChannel>;
 }
 
+/**
+ * Base abstract class to implement an transversal.
+ * A transversal is a special kind of assemblage that provides cross-cutting concerns.
+ *
+ * @example
+ * ```typescript
+ * @Transversal()
+ * class LoggingTransversal extends AbstractTransversal {
+ *   onInit() {
+ *     console.log('Transversal initialized');
+ *   }
+ *
+ *   @Before('execution(UserService.*)')
+ *   logBefore(context: AdviceContext) {
+ *     console.log('Before:', context.methodName);
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AbstractTransversal {
+    [key: string]: any;
+    /**
+     * Called on transversal class registration by assembler.
+     * This is called when the transversal is registered, not when it is instantiated.
+     *
+     * @param context The assembler's context.
+     * @param configuration The configuration object.
+     */
+    static onRegister(context: AssemblerContext, configuration?: Record<string, any>): void;
+    /**
+     * Called on transversal instantiation in less dependent to more dependent order
+     * after the dependency tree is fully resolved.
+     *
+     * @param context The assembler's context.
+     * @param configuration The configuration object.
+     */
+    abstract onInit?(context: AssemblerContext, configuration?: Record<string, any>): void | Promise<void>;
+    /**
+     * Called by the Assembler when all aspects have been initialized with onInit,
+     * in more dependent to less dependent order (reverse of onInit).
+     *
+     * @param context The assembler's context.
+     * @param configuration The configuration object.
+     */
+    abstract onInited?(context: AssemblerContext, configuration?: Record<string, any>): void | Promise<void>;
+    /**
+     * Called when transversal instance is disposed.
+     *
+     * @param context The assembler's context.
+     * @param configuration The configuration object.
+     */
+    abstract onDispose?(context: AssemblerContext, configuration?: Record<string, any>): void;
+    /**
+     * Dispose the transversal instance.
+     * Called to clean up resources when the transversal is no longer needed.
+     */
+    abstract dispose?(): void;
+    /**
+     * When decorated with '@Waitable', waits for a specific property to be truthy before resolving.
+     * This can be used to ensure the transversal is fully initialized before use.
+     */
+    abstract whenReady?(): Promise<void>;
+}
+
+/**
+ * Advice definition.
+ * Represents a single advice to be applied at a join point.
+ */
+export declare interface Advice {
+    /** The type of advice */
+    type: AdviceType;
+    /** The pointcut expression */
+    pointcut: string;
+    /** The advice method to execute */
+    method: Function;
+    /** The transversal instance that owns this advice */
+    transversalInstance: any;
+    /** The priority of this advice (higher values execute first) */
+    priority: number;
+    /** Whether this advice is enabled */
+    enabled: boolean;
+    /** Optional role identifier extracted from pointcut */
+    role?: string;
+    /** Optional config specific to this advice (from @Affect) */
+    config?: Record<string, any>;
+}
+
+/**
+ * Advice execution context.
+ * Extends JoinPoint with the proceed function for around advice.
+ */
+export declare interface AdviceContext extends JoinPoint {
+    /** Function to proceed to the next advice or the original method (for around advice) */
+    proceed?: () => any;
+    /** Optional config specific to this advice execution (from @Affect) */
+    config?: Record<string, any>;
+}
+
+/**
+ * Type of advice: before, after, or around.
+ */
+export declare type AdviceType = 'before' | 'after' | 'around';
+
+/**
+ * Method decorator to explicitly apply a transversal to a specific method.
+ * This bypasses the automatic pointcut matching and forces the transversal on this method.
+ *
+ * @example
+ * ```typescript
+ * @Assemblage()
+ * class UserService {
+ *   @Affect(LoggingTransversal)
+ *   create(data: any) { ... }
+ *
+ *   @Affect(LoggingTransversal, { role: 'audit' })
+ *   @Affect(ValidationTransversal)
+ *   update(id: string, data: any) { ... }
+ * }
+ * ```
+ */
+export declare function Affect(transversal: Identifier<any>, config?: Record<string, any>): MethodDecorator;
+
+/**
+ * Configuration for explicitly applying an transversal to a method.
+ */
+export declare interface AffectedMethodConfig {
+    /** The transversal class to apply */
+    transversal: Identifier<any>;
+    /** Optional role to filter which advices from the transversal should apply */
+    role?: string;
+    /** Optional configuration for the transversal */
+    config?: Record<string, any>;
+}
+
+/**
+ * Decorator to define an after advice.
+ * The advice will be executed after the target method completes.
+ * The advice receives the method result in context.result.
+ *
+ * @param pointcut The pointcut expression
+ * @param priority Optional priority (higher values execute first, default: 0)
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * @After('execution(UserService.*)')
+ * logAfter(context: AdviceContext) {
+ *   console.log('Result:', context.result);
+ * }
+ * ```
+ */
+export declare function After(pointcut: string, priority?: number): (target: any, propertyKey: string, _descriptor: PropertyDescriptor) => void;
+
+/**
+ * Decorator to define an around advice.
+ * The advice wraps the target method and can control its execution.
+ * Call context.proceed() to continue to the next advice or the original method.
+ *
+ * @param pointcut The pointcut expression
+ * @param priority Optional priority (higher values execute first, default: 0)
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * @Around('execution(UserService.save)')
+ * async measureTime(context: AdviceContext) {
+ *   const start = Date.now();
+ *   const result = await context.proceed();
+ *   console.log(`Took ${Date.now() - start}ms`);
+ *   return result;
+ * }
+ * ```
+ */
+export declare function Around(pointcut: string, priority?: number): (target: any, propertyKey: string, _descriptor: PropertyDescriptor) => void;
+
 /**
  * Mark a class as `Assemblage` and cache its definition.
  *
@@ -116,11 +291,16 @@ export declare abstract class AbstractListenerCollection {
  */
 export declare const Assemblage: <T>(definition?: AssemblageDefinition) => ClassDecorator;
 
+/**
+ * Assemblage definition interface.
+ * Defines the configuration options for the @Assemblage decorator.
+ */
 export declare interface AssemblageDefinition {
-    singleton?: false;
+    singleton?: boolean;
     events?: string[];
     inject?: Injection<unknown>[];
     use?: InstanceInjection<unknown>[];
+    engage?: TransversalInjection<unknown>[];
     tags?: string | string[];
     metadata?: Record<string, any>;
     global?: Record<string, any>;
@@ -226,6 +406,24 @@ export declare const Await: (property: string, interval?: number) => MethodDecor
  */
 declare type BaseInjection<T> = Tuple<[Abstract<T>, Concrete<T>]>;
 
+/**
+ * Decorator to define a before advice.
+ * The advice will be executed before the target method.
+ *
+ * @param pointcut The pointcut expression (e.g., "execution(ClassName.methodName)")
+ * @param priority Optional priority (higher values execute first, default: 0)
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * @Before('execution(UserService.save)', 100)
+ * validateInput(context: AdviceContext) {
+ *   // Validate before saving
+ * }
+ * ```
+ */
+export declare function Before(pointcut: string, priority?: number): (target: any, propertyKey: string, _descriptor: PropertyDescriptor) => void;
+
 /**
  * Describes a buildable object.
  */
@@ -254,7 +452,7 @@ declare type ConcreteInjection<T> = Tuple<[Concrete<T>]>;
  * Injects the injectable's configuration object.
  * @returns A parameter decorator
  */
-export declare const Configuration: (param: void) => ParameterDecorator;
+export declare const Configuration: (param?: void | undefined) => ParameterDecorator;
 
 /**
  * Injectable binds a concrete class to an abstract class as identifier
@@ -295,7 +493,7 @@ export declare type ConstructorDecoratorFunction = <T extends new (...args: any[
  * Injects the injectable's public context.
  * @returns A parameter decorator
  */
-export declare const Context: (param: void) => ParameterDecorator;
+export declare const Context: (param?: void | undefined) => ParameterDecorator;
 
 /**
  * Create a custom decorator that adds a function called after the original constructor
@@ -388,13 +586,13 @@ declare interface DecoratorMetadata_2 {
  * Injects the injectable's definition object.
  * @returns A parameter decorator
  */
-export declare const Definition: (param: void) => ParameterDecorator;
+export declare const Definition: (param?: void | undefined) => ParameterDecorator;
 
 /**
  * Injects the injectable's dispose function.
  * @returns A parameter decorator
  */
-export declare const Dispose: (param: void) => ParameterDecorator;
+export declare const Dispose: (param?: void | undefined) => ParameterDecorator;
 
 /**
  * `EventChannel` extends `string`.
@@ -468,7 +666,7 @@ export declare const getParamValueKey: (decoratorName: string) => string;
  * @param identifier The identifier of the global object to inject
  * @returns A parameter decorator
  */
-declare const Global_2: (param: string | symbol) => ParameterDecorator;
+declare const Global_2: (param?: string | symbol | undefined) => ParameterDecorator;
 export { Global_2 as Global }
 
 declare class HookManager {
@@ -511,6 +709,8 @@ declare class Injectable<T> implements AbstractInjectable<T> {
     private cachedInjections?;
     /** Cached objects to avoid repeated definition access. */
     private cachedObjects?;
+    /** Cached aspects to avoid repeated definition access. */
+    private cachedTransversals?;
     /** Cached tags to avoid repeated definition access. */
     private cachedTags?;
     /** Cached events to avoid repeated definition access. */
@@ -522,6 +722,18 @@ declare class Injectable<T> implements AbstractInjectable<T> {
     private builder;
     static of<TNew>(buildable: Buildable<TNew>, privateContext: AssemblerPrivateContext, publicContext: AssemblerContext): Injectable<TNew>;
     private constructor();
+    /**
+     * Converts an TransversalInjection to an Injection format for registration.
+     * Supports all TransversalInjection formats:
+     * - [Concrete]
+     * - [Concrete, config]
+     * - [Abstract, Concrete]
+     * - [Abstract, Concrete, config]
+     *
+     * @param transversal The transversal injection to convert
+     * @returns An Injection that can be registered in the context
+     */
+    private resolveTransversalToInjection;
     /**
      * Dispose the injectable by deleting its singleton if exists
      * and deleting all injectable's properties.
@@ -567,6 +779,10 @@ declare class Injectable<T> implements AbstractInjectable<T> {
      * Injectable assemblage's own objects (e.g. instances) injections defined in its decorator's definition.
      */
     get objects(): InstanceInjection<unknown>[];
+    /**
+     * Injectable assemblage's transversals defined in its decorator's definition.
+     */
+    get transversals(): any[];
     /**
      * Tags passed in assemblage's definition.
      */
@@ -630,6 +846,30 @@ declare type InstanceInjection<T> = Tuple<[Identifier<T> | string | symbol, T]>;
  */
 export declare const isAssemblage: <T>(target: Concrete<T>) => boolean;
 
+/**
+ * Checks if a class is decorated with @Transversal
+ * @param target The class to check
+ * @returns True if the class is a transversal
+ */
+export declare function isTransversal(target: any): boolean;
+
+/**
+ * Join point information.
+ * Represents the point of execution where an advice is applied.
+ */
+export declare interface JoinPoint {
+    /** The target instance */
+    target: any;
+    /** The name of the method being called */
+    methodName: string;
+    /** The arguments passed to the method */
+    args: any[];
+    /** The result of the method (for after advice) */
+    result?: any;
+    /** The error thrown by the method (if any) */
+    error?: any;
+}
+
 declare interface LifecycleManager {
     prepareInitHook<T = AbstractAssemblage>(instance: T, configuration?: Record<string, any>): unknown[];
 }
@@ -773,7 +1013,7 @@ declare interface ObjectProvider {
  *   ) {}
  * }
  */
-export declare const Optional: (param: any) => ParameterDecorator;
+export declare const Optional: (param?: any) => ParameterDecorator;
 
 /**
  * Configuration for creating a parameter decorator.
@@ -802,7 +1042,7 @@ export declare class ParameterDecoratorFactory {
      * @param config The decorator configuration
      * @returns A parameter decorator function
      */
-    static create<T>(config: ParameterDecoratorConfig): (param: T) => ParameterDecorator;
+    static create<T>(config: ParameterDecoratorConfig): (param?: T | undefined) => ParameterDecorator;
     /**
      * Creates the actual decorator function.
      */
@@ -885,11 +1125,192 @@ declare interface TagResolver {
     tagged(...tags: string[]): any[];
 }
 
+/**
+ * Decorator to define a class as an Transversal.
+ * An Transversal is a specialized Assemblage that:
+ * - Cannot have inject or use properties (must be empty)
+ * - Receives dependencies through constructor parameters resolved from parent context
+ * - Is singleton by default
+ * - Cannot be combined with @Assemblage decorator
+ *
+ * @param definition Optional assemblage definition (inject and use will be ignored)
+ * @returns Class decorator
+ *
+ * @example
+ * ```typescript
+ * @Transversal()
+ * class LoggingTransversal extends AbstractTransversal {
+ *   constructor(private logger: Logger) {
+ *     super();
+ *   }
+ *
+ *   @Before('execution(UserService.*)')
+ *   logBefore(context: AdviceContext) {
+ *     this.logger.log('Before:', context.methodName);
+ *   }
+ * }
+ * ```
+ */
+export declare function Transversal(definition?: Omit<AssemblageDefinition, 'inject' | 'use'>): <T extends new (...args: any[]) => any>(target: T) => void | T;
+
+/**
+ * Transversal injection definition.
+ * A transversal can be injected with or without configuration.
+ * Supports both direct injection, abstraction pattern, and advanced configuration with roles.
+ *
+ * @example
+ * ```typescript
+ * // Without configuration (backward compatible)
+ * transversals: [[LoggingTransversal]]
+ *
+ * // With configuration (backward compatible)
+ * transversals: [[LoggingTransversal, { level: 'debug' }]]
+ *
+ * // With abstraction (like inject[])
+ * transversals: [[AbstractLoggingTransversal, LoggingTransversal]]
+ *
+ * // With abstraction and configuration
+ * transversals: [[AbstractLoggingTransversal, LoggingTransversal, { level: 'debug' }]]
+ *
+ * // NEW: With role and method filtering
+ * transversals: [
+ *   {
+ *     transversal: LoggingTransversal,
+ *     role: 'method-entry',
+ *     methods: ['create', 'update']
+ *   },
+ *   {
+ *     transversal: LoggingTransversal,  // Same transversal, different config
+ *     role: 'method-exit',
+ *     methods: '*'
+ *   }
+ * ]
+ *
+ * // NEW: With abstraction and role configuration
+ * transversals: [
+ *   {
+ *     transversal: [AbstractLoggingTransversal, LoggingTransversal],
+ *     role: 'audit',
+ *     methods: (name) => name.startsWith('delete')
+ *   }
+ * ]
+ * ```
+ */
+declare type TransversalInjection<T> = [Identifier<T>] | [Identifier<T>, Record<string, any>] | [Abstract<T>, Concrete<T>] | [Abstract<T>, Concrete<T>, Record<string, any>];
+
+/**
+ * TransversalManager manages transversal registration and advice resolution.
+ */
+export declare class TransversalManager {
+    private context;
+    private static instances;
+    private static transversalInstances;
+    private static transversalMetadata;
+    private constructor();
+    /**
+     * Gets or creates an TransversalManager instance for a given context.
+     *
+     * @param context The assembler context
+     * @returns The TransversalManager instance for this context
+     */
+    static getInstance(context: AssemblerContext): TransversalManager;
+    /**
+     * Gets the singleton transversal instance by class name.
+     * CRITICAL: This ensures that aspects injected in constructors use the same instance as weaving.
+     *
+     * @param transversalClassName The name of the transversal class
+     * @returns The transversal instance or undefined if not registered
+     */
+    getTransversalInstance(transversalClassName: string): any | undefined;
+    /**
+     * Clears all global transversal instances and metadata.
+     * Useful for testing to reset state between tests.
+     * WARNING: This will clear ALL aspects globally across all contexts.
+     */
+    static resetGlobalState(): void;
+    /**
+     * Registers a transversal from its injection definition.
+     * The transversal is resolved from the context and its advices are extracted.
+     *
+     * - [TransversalClass] - Simple injection
+     * - [TransversalClass, config] - With configuration
+     * - [AbstractClass, ConcreteClass] - With abstraction
+     * - [AbstractClass, ConcreteClass, config] - With abstraction and config
+     *
+     * @param transversalInjection The transversal injection tuple or config object
+     * @param resolveContext Optional context to use for resolving the transversal (if different from manager's context)
+     * @param assemblageIdentifier Optional identifier for the assemblage context (for configuration tracking)
+     */
+    registerTransversal(transversalInjection: TransversalInjection<any>, resolveContext?: AssemblerContext): void;
+    /**
+     * Extracts advices from a transversal class instance.
+     * Advices are stored in definition.metadata.advices by the decorators.
+     * Now also extracts role information from the pointcut.
+     *
+     * @param TransversalClass The transversal class
+     * @param transversalInstance The transversal instance
+     * @returns Array of extracted advices
+     */
+    private extractAdvices;
+    /**
+     * Gets applicable aspects for a target class.
+     * Uses both global transversal metadata and local context configuration.
+     *
+     * @param concrete The target class
+     * @param contextId Optional assemblage context identifier for local filtering
+     * @returns Array of applicable transversal metadata with local configuration applied
+     */
+    getAspectsForTarget(concrete: Concrete<any>): TransversalMetadata[];
+    /**
+     * Checks if a transversal has any advice matching the target class.
+     *
+     * @param metadata The transversal metadata
+     * @param concrete The target class
+     * @returns True if any advice matches
+     */
+    private hasMatchingAdviceForClass;
+    /**
+     * Converts a wildcard pattern to a regular expression.
+     * Reused from PointcutMatcher logic.
+     *
+     * @param pattern The pattern with wildcards
+     * @returns A RegExp for matching
+     */
+    private patternToRegex;
+    /**
+     * Gets advices applicable to a specific join point.
+     * Includes advices from:
+     * 1. Aspects matched by pointcut regex (automatic)
+     * 2. Aspects explicitly applied via @Affect decorator (manual)
+     *
+     * @param joinPoint The join point to match
+     * @param aspects The aspects to search (from pointcut matching)
+     * @param contextId Optional context identifier for method filtering
+     * @param target Optional target instance (for @Affect lookup)
+     * @param propertyKey Optional property key (for @Affect lookup)
+     * @returns Array of applicable advices, sorted by priority (highest first)
+     */
+    getAdvicesForJoinPoint(joinPoint: JoinPoint, transversals: TransversalMetadata[], target?: any, propertyKey?: string | symbol): Advice[];
+}
+
+/**
+ * Transversal metadata.
+ * Contains information about a registered transversal.
+ */
+export declare interface TransversalMetadata {
+    /** The assemblage definition of the transversal */
+    definition: any;
+    /** The advices defined in this transversal */
+    advices: Advice[];
+    /** The transversal instance */
+    instance?: any;
+}
+
 /**
  * Injects an object passed with `string` or `symbol` identifier.
  * @param identifier The identifier of the object to inject
  * @returns A parameter decorator
  */
-export declare const Use: (param: string | symbol) => ParameterDecorator;
+export declare const Use: (param?: string | symbol | undefined) => ParameterDecorator;
 
 export { }

package/dist/index.js

@@ -11,18 +11,22 @@ const abstract = require('./index7.js');
 const types = require('./index8.js');
 const listenerCollection_abstract = require('./index9.js');
 const eventManager_abstract = require('./index10.js');
-const _await = require('./index11.js');
-const indexFactory = require('./index12.js');
-const parameterDecoratorFactory = require('./index13.js');
-const context = require('./index14.js');
-const configuration = require('./index15.js');
-const definition = require('./index16.js');
-const dispose = require('./index17.js');
-const use = require('./index18.js');
-const global = require('./index19.js');
-const optional = require('./index20.js');
-const helpers$1 = require('./index21.js');
-const constructorDecorator = require('./index22.js');
+const decorators = require('./index11.js');
+const affect = require('./index12.js');
+const transversalManager = require('./index13.js');
+const abstract$1 = require('./index14.js');
+const _await = require('./index15.js');
+const indexFactory = require('./index16.js');
+const parameterDecoratorFactory = require('./index17.js');
+const context = require('./index18.js');
+const configuration = require('./index19.js');
+const definition = require('./index20.js');
+const dispose = require('./index21.js');
+const use = require('./index22.js');
+const global = require('./index23.js');
+const optional = require('./index24.js');
+const helpers$1 = require('./index25.js');
+const constructorDecorator = require('./index26.js');
 
 
 
@@ -38,6 +42,14 @@ exports.AbstractAssemblage = abstract.AbstractAssemblage;
 exports.AbstractAssembler = types.AbstractAssembler;
 exports.AbstractListenerCollection = listenerCollection_abstract.AbstractListenerCollection;
 exports.AbstractEventManager = eventManager_abstract.AbstractEventManager;
+exports.After = decorators.After;
+exports.Around = decorators.Around;
+exports.Before = decorators.Before;
+exports.Transversal = decorators.Transversal;
+exports.isTransversal = decorators.isTransversal;
+exports.Affect = affect.Affect;
+exports.TransversalManager = transversalManager.TransversalManager;
+exports.AbstractTransversal = abstract$1.AbstractTransversal;
 exports.Await = _await.Await;
 exports.createParamIndexDecorator = indexFactory.createParamIndexDecorator;
 exports.ParameterDecoratorFactory = parameterDecoratorFactory.ParameterDecoratorFactory;

package/dist/index.mjs

@@ -7,15 +7,19 @@ export { AbstractAssemblage } from './index7.mjs';
 export { AbstractAssembler } from './index8.mjs';
 export { AbstractListenerCollection } from './index9.mjs';
 export { AbstractEventManager } from './index10.mjs';
-export { Await } from './index11.mjs';
-export { createParamIndexDecorator } from './index12.mjs';
-export { ParameterDecoratorFactory } from './index13.mjs';
-export { Context } from './index14.mjs';
-export { Configuration } from './index15.mjs';
-export { Definition } from './index16.mjs';
-export { Dispose } from './index17.mjs';
-export { Use, decorateUse } from './index18.mjs';
-export { Global, decorateGlobal } from './index19.mjs';
-export { Optional } from './index20.mjs';
-export { getDecoratedParametersIndexes, getParamIndexKey, getParamValueKey, getParameterIndexes, getParameterValues } from './index21.mjs';
-export { ConstructorDecorator, createConstructorDecorator } from './index22.mjs';
+export { After, Around, Before, Transversal, isTransversal } from './index11.mjs';
+export { Affect } from './index12.mjs';
+export { TransversalManager } from './index13.mjs';
+export { AbstractTransversal } from './index14.mjs';
+export { Await } from './index15.mjs';
+export { createParamIndexDecorator } from './index16.mjs';
+export { ParameterDecoratorFactory } from './index17.mjs';
+export { Context } from './index18.mjs';
+export { Configuration } from './index19.mjs';
+export { Definition } from './index20.mjs';
+export { Dispose } from './index21.mjs';
+export { Use, decorateUse } from './index22.mjs';
+export { Global, decorateGlobal } from './index23.mjs';
+export { Optional } from './index24.mjs';
+export { getDecoratedParametersIndexes, getParamIndexKey, getParamValueKey, getParameterIndexes, getParameterValues } from './index25.mjs';
+export { ConstructorDecorator, createConstructorDecorator } from './index26.mjs';