@orchestr-sh/orchestr 1.9.15 → 1.11.0

package/dist/Events/Concerns/Dispatchable.d.mts

@@ -0,0 +1,118 @@
+//#region src/Events/Concerns/Dispatchable.d.ts
+/**
+ * Dispatchable Concern
+ *
+ * Provides static dispatch methods for events
+ * This mixin is applied to the Event base class to enable:
+ * - Event.dispatch() - Dispatch immediately
+ * - Event.dispatchIf() - Conditional dispatch
+ * - Event.dispatchUnless() - Negative conditional dispatch
+ *
+ * @example
+ * ```typescript
+ * // Dispatch an event
+ * UserRegistered.dispatch(user);
+ *
+ * // Conditional dispatch
+ * UserRegistered.dispatchIf(shouldNotify, user);
+ *
+ * // Dispatch unless condition is true
+ * UserRegistered.dispatchUnless(user.isAdmin, user);
+ *
+ * // Dispatch and wait for first response
+ * const result = UserRegistered.until(user);
+ * ```
+ */
+/**
+ * Dispatchable mixin class
+ *
+ * Provides static methods for dispatching events
+ */
+declare class Dispatchable {
+  /**
+   * Dispatch the event with the given arguments
+   *
+   * Creates a new instance of the event class and dispatches it through the event dispatcher
+   *
+   * @param args - Constructor arguments for the event
+   * @returns Array of listener responses
+   *
+   * @example
+   * ```typescript
+   * class UserRegistered extends Event {
+   *   constructor(public user: User) {
+   *     super();
+   *   }
+   * }
+   *
+   * // Dispatch the event
+   * UserRegistered.dispatch(user);
+   * ```
+   */
+  static dispatch(...args: any[]): any[];
+  /**
+   * Dispatch the event if the given condition is true
+   *
+   * @param condition - Boolean or function that returns boolean
+   * @param args - Constructor arguments for the event
+   * @returns Array of listener responses or empty array if condition is false
+   *
+   * @example
+   * ```typescript
+   * // Dispatch if condition is true
+   * UserRegistered.dispatchIf(user.isActive, user);
+   *
+   * // Dispatch if function returns true
+   * UserRegistered.dispatchIf(() => shouldNotify(), user);
+   * ```
+   */
+  static dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[];
+  /**
+   * Dispatch the event unless the given condition is true
+   *
+   * @param condition - Boolean or function that returns boolean
+   * @param args - Constructor arguments for the event
+   * @returns Array of listener responses or empty array if condition is true
+   *
+   * @example
+   * ```typescript
+   * // Dispatch unless user is admin
+   * UserRegistered.dispatchUnless(user.isAdmin, user);
+   *
+   * // Dispatch unless function returns true
+   * UserRegistered.dispatchUnless(() => user.hasRole('admin'), user);
+   * ```
+   */
+  static dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[];
+  /**
+   * Dispatch the event and call the first listener that doesn't return null
+   *
+   * This is useful when you want to get a response from an event listener
+   *
+   * @param args - Constructor arguments for the event
+   * @returns First non-null listener response
+   *
+   * @example
+   * ```typescript
+   * // Get a response from the first listener
+   * const result = UserRegistered.until(user);
+   * if (result === false) {
+   *   // Listener vetoed the operation
+   * }
+   * ```
+   */
+  static until(...args: any[]): any;
+}
+/**
+ * Apply Dispatchable mixin to Event class
+ *
+ * This function copies all static methods from Dispatchable to the target Event class
+ *
+ * @param eventClass - The Event class to apply the mixin to
+ *
+ * @internal
+ */
+declare function applyDispatchable(eventClass: any): void;
+//#endregion
+export { Dispatchable, applyDispatchable };
+//# sourceMappingURL=Dispatchable.d.mts.map

package/dist/Events/Concerns/Dispatchable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatchable.d.mts","names":[],"sources":["../../../src/Events/Concerns/Dispatchable.ts"],"mappings":";;AAiCA;;;;;;;;;;;;;;;;AA6HA;;;;;;;;;;;;cA7Ha,YAAA;;;;;;;;;;;;;;;;;;;;;SAqBJ,QAAA,CAAA,GAAY,IAAA;;;;;;;;;;;;;;;;;SAyBZ,UAAA,CAAW,SAAA,gCAAyC,IAAA;;;;;;;;;;;;;;;;;SA0BpD,cAAA,CAAe,SAAA,gCAAyC,IAAA;;;;;;;;;;;;;;;;;;SA2BxD,KAAA,CAAA,GAAS,IAAA;AAAA;;;;;;;;;;iBA0BF,iBAAA,CAAkB,UAAA"}

package/dist/Events/Concerns/Dispatchable.mjs

@@ -0,0 +1,2 @@
+import{Facade as e}from"../../Support/Facade.mjs";var t=class{static dispatch(...t){let n=e.getFacadeApplication();if(!n)throw Error(`Application not initialized. Cannot dispatch event.`);return n.make(`events`).dispatch(new this(...t))}static dispatchIf(e,...t){return(typeof e==`function`?e():e)?this.dispatch(...t):[]}static dispatchUnless(e,...t){return(typeof e==`function`?e():e)?[]:this.dispatch(...t)}static until(...t){let n=e.getFacadeApplication();if(!n)throw Error(`Application not initialized. Cannot dispatch event.`);return n.make(`events`).until(new this(...t))}};function n(e){let n=Object.getOwnPropertyNames(t);for(let r of n){if(r===`constructor`||r===`prototype`||r===`length`||r===`name`)continue;let n=Object.getOwnPropertyDescriptor(t,r);n&&Object.defineProperty(e,r,{value:n.value,enumerable:!1,configurable:!0,writable:!0})}}export{t as Dispatchable,n as applyDispatchable};
+//# sourceMappingURL=Dispatchable.mjs.map

package/dist/Events/Concerns/Dispatchable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatchable.mjs","names":[],"sources":["../../../src/Events/Concerns/Dispatchable.ts"],"sourcesContent":["/**\n * Dispatchable Concern\n *\n * Provides static dispatch methods for events\n * This mixin is applied to the Event base class to enable:\n * - Event.dispatch() - Dispatch immediately\n * - Event.dispatchIf() - Conditional dispatch\n * - Event.dispatchUnless() - Negative conditional dispatch\n *\n * @example\n * ```typescript\n * // Dispatch an event\n * UserRegistered.dispatch(user);\n *\n * // Conditional dispatch\n * UserRegistered.dispatchIf(shouldNotify, user);\n *\n * // Dispatch unless condition is true\n * UserRegistered.dispatchUnless(user.isAdmin, user);\n *\n * // Dispatch and wait for first response\n * const result = UserRegistered.until(user);\n * ```\n */\n\nimport type { DispatcherContract } from '@/Contracts/Events/Dispatcher';\nimport { Facade } from '@/Support/Facade';\n\n/**\n * Dispatchable mixin class\n *\n * Provides static methods for dispatching events\n */\nexport class Dispatchable {\n  /**\n   * Dispatch the event with the given arguments\n   *\n   * Creates a new instance of the event class and dispatches it through the event dispatcher\n   *\n   * @param args - Constructor arguments for the event\n   * @returns Array of listener responses\n   *\n   * @example\n   * ```typescript\n   * class UserRegistered extends Event {\n   *   constructor(public user: User) {\n   *     super();\n   *   }\n   * }\n   *\n   * // Dispatch the event\n   * UserRegistered.dispatch(user);\n   * ```\n   */\n  static dispatch(...args: any[]): any[] {\n    const app = Facade.getFacadeApplication();\n    if (!app) {\n      throw new Error('Application not initialized. Cannot dispatch event.');\n    }\n\n    return app.make<DispatcherContract>('events').dispatch(new (this as any)(...args));\n  }\n\n  /**\n   * Dispatch the event if the given condition is true\n   *\n   * @param condition - Boolean or function that returns boolean\n   * @param args - Constructor arguments for the event\n   * @returns Array of listener responses or empty array if condition is false\n   *\n   * @example\n   * ```typescript\n   * // Dispatch if condition is true\n   * UserRegistered.dispatchIf(user.isActive, user);\n   *\n   * // Dispatch if function returns true\n   * UserRegistered.dispatchIf(() => shouldNotify(), user);\n   * ```\n   */\n  static dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[] {\n    const shouldDispatch = typeof condition === 'function' ? condition() : condition;\n\n    if (shouldDispatch) {\n      return this.dispatch(...args);\n    }\n\n    return [];\n  }\n\n  /**\n   * Dispatch the event unless the given condition is true\n   *\n   * @param condition - Boolean or function that returns boolean\n   * @param args - Constructor arguments for the event\n   * @returns Array of listener responses or empty array if condition is true\n   *\n   * @example\n   * ```typescript\n   * // Dispatch unless user is admin\n   * UserRegistered.dispatchUnless(user.isAdmin, user);\n   *\n   * // Dispatch unless function returns true\n   * UserRegistered.dispatchUnless(() => user.hasRole('admin'), user);\n   * ```\n   */\n  static dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[] {\n    const shouldNotDispatch = typeof condition === 'function' ? condition() : condition;\n\n    if (!shouldNotDispatch) {\n      return this.dispatch(...args);\n    }\n\n    return [];\n  }\n\n  /**\n   * Dispatch the event and call the first listener that doesn't return null\n   *\n   * This is useful when you want to get a response from an event listener\n   *\n   * @param args - Constructor arguments for the event\n   * @returns First non-null listener response\n   *\n   * @example\n   * ```typescript\n   * // Get a response from the first listener\n   * const result = UserRegistered.until(user);\n   * if (result === false) {\n   *   // Listener vetoed the operation\n   * }\n   * ```\n   */\n  static until(...args: any[]): any {\n    const app = Facade.getFacadeApplication();\n    if (!app) {\n      throw new Error('Application not initialized. Cannot dispatch event.');\n    }\n\n    return app.make<DispatcherContract>('events').until(new (this as any)(...args));\n  }\n}\n\n/**\n * Type declaration to merge Dispatchable methods into Event class\n * This enables TypeScript to understand that Event has these static methods\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface Event extends Dispatchable {}\n\n/**\n * Apply Dispatchable mixin to Event class\n *\n * This function copies all static methods from Dispatchable to the target Event class\n *\n * @param eventClass - The Event class to apply the mixin to\n *\n * @internal\n */\nexport function applyDispatchable(eventClass: any): void {\n  // Get all static methods from Dispatchable\n  const staticMethods = Object.getOwnPropertyNames(Dispatchable);\n\n  for (const name of staticMethods) {\n    // Skip constructor and prototype\n    if (name === 'constructor' || name === 'prototype' || name === 'length' || name === 'name') {\n      continue;\n    }\n\n    // Get the property descriptor\n    const descriptor = Object.getOwnPropertyDescriptor(Dispatchable, name);\n\n    if (descriptor) {\n      // Copy the method to the event class\n      Object.defineProperty(eventClass, name, {\n        value: descriptor.value,\n        enumerable: false,\n        configurable: true,\n        writable: true,\n      });\n    }\n  }\n}\n"],"mappings":"kDAiCA,IAAa,EAAb,KAA0B,CAqBxB,OAAO,SAAS,GAAG,EAAoB,CACrC,IAAM,EAAM,EAAO,sBAAsB,CACzC,GAAI,CAAC,EACH,MAAU,MAAM,sDAAsD,CAGxE,OAAO,EAAI,KAAyB,SAAS,CAAC,SAAS,IAAK,KAAa,GAAG,EAAK,CAAC,CAmBpF,OAAO,WAAW,EAAsC,GAAG,EAAoB,CAO7E,OANuB,OAAO,GAAc,WAAa,GAAW,CAAG,GAG9D,KAAK,SAAS,GAAG,EAAK,CAGxB,EAAE,CAmBX,OAAO,eAAe,EAAsC,GAAG,EAAoB,CAOjF,OAN0B,OAAO,GAAc,WAAa,GAAW,CAAG,GAMnE,EAAE,CAHA,KAAK,SAAS,GAAG,EAAK,CAuBjC,OAAO,MAAM,GAAG,EAAkB,CAChC,IAAM,EAAM,EAAO,sBAAsB,CACzC,GAAI,CAAC,EACH,MAAU,MAAM,sDAAsD,CAGxE,OAAO,EAAI,KAAyB,SAAS,CAAC,MAAM,IAAK,KAAa,GAAG,EAAK,CAAC,GAoBnF,SAAgB,EAAkB,EAAuB,CAEvD,IAAM,EAAgB,OAAO,oBAAoB,EAAa,CAE9D,IAAK,IAAM,KAAQ,EAAe,CAEhC,GAAI,IAAS,eAAiB,IAAS,aAAe,IAAS,UAAY,IAAS,OAClF,SAIF,IAAM,EAAa,OAAO,yBAAyB,EAAc,EAAK,CAElE,GAEF,OAAO,eAAe,EAAY,EAAM,CACtC,MAAO,EAAW,MAClB,WAAY,GACZ,aAAc,GACd,SAAU,GACX,CAAC"}

package/dist/Events/Contracts/Dispatcher.d.cts

@@ -0,0 +1,148 @@
+import { Event } from "../Event.cjs";
+import { EventListener, EventSubscriber } from "../types.cjs";
+
+//#region src/Events/Contracts/Dispatcher.d.ts
+/**
+ * Event Dispatcher Contract
+ *
+ * Defines the interface for the event dispatcher service.
+ * The dispatcher manages event listeners and dispatches events to them.
+ *
+ * @example
+ * ```typescript
+ * const dispatcher = app.make<DispatcherContract>('events');
+ *
+ * // Register a listener
+ * dispatcher.listen(UserRegistered, SendWelcomeEmail);
+ *
+ * // Dispatch an event
+ * dispatcher.dispatch(new UserRegistered(user));
+ * ```
+ */
+interface DispatcherContract {
+  /**
+   * Register an event listener
+   *
+   * @param events - Event name(s) to listen for
+   * @param listener - Listener to invoke when event is dispatched
+   *
+   * @example
+   * ```typescript
+   * // Single event
+   * dispatcher.listen('user.registered', SendWelcomeEmail);
+   *
+   * // Multiple events
+   * dispatcher.listen(['user.registered', 'user.updated'], LogUserActivity);
+   *
+   * // Wildcard
+   * dispatcher.listen('user.*', LogAllUserEvents);
+   * ```
+   */
+  listen(events: string | string[], listener: EventListener): void;
+  /**
+   * Check if an event has any listeners
+   *
+   * @param eventName - The event name to check
+   * @returns True if the event has listeners
+   */
+  hasListeners(eventName: string): boolean;
+  /**
+   * Register an event subscriber
+   *
+   * Subscribers can register multiple event listeners at once
+   *
+   * @param subscriber - The subscriber instance
+   *
+   * @example
+   * ```typescript
+   * class UserEventSubscriber implements EventSubscriber {
+   *   subscribe(events: DispatcherContract) {
+   *     events.listen('user.registered', this.onRegistered.bind(this));
+   *     events.listen('user.updated', this.onUpdated.bind(this));
+   *   }
+   *
+   *   onRegistered(event: UserRegistered) { }
+   *   onUpdated(event: UserUpdated) { }
+   * }
+   *
+   * dispatcher.subscribe(new UserEventSubscriber());
+   * ```
+   */
+  subscribe(subscriber: EventSubscriber): void;
+  /**
+   * Dispatch an event to all listeners
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @param halt - Stop dispatching if a listener returns false
+   * @returns Array of results from listeners
+   *
+   * @example
+   * ```typescript
+   * // Dispatch with event instance
+   * dispatcher.dispatch(new UserRegistered(user));
+   *
+   * // Dispatch with event name and payload
+   * dispatcher.dispatch('user.registered', [user]);
+   *
+   * // Halt on first false return
+   * dispatcher.dispatch(new OrderProcessing(order), [], true);
+   * ```
+   */
+  dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+  /**
+   * Dispatch an event until a listener returns a non-null response
+   *
+   * This is useful for events where you want the first "truthy" response
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @returns The first non-null response from a listener
+   *
+   * @example
+   * ```typescript
+   * // Get the first validation result
+   * const isValid = dispatcher.until(new ValidateOrder(order));
+   * ```
+   */
+  until(event: string | Event, payload?: any[]): any;
+  /**
+   * Queue an event for later dispatch
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   *
+   * @example
+   * ```typescript
+   * dispatcher.push('send.notification', [user, message]);
+   * // Later...
+   * dispatcher.flush('send.notification');
+   * ```
+   */
+  push(event: string, payload?: any[]): void;
+  /**
+   * Flush (dispatch) all queued events for a specific event name
+   *
+   * @param event - Event name to flush
+   */
+  flush(event: string): void;
+  /**
+   * Remove all listeners for an event
+   *
+   * @param event - Event name
+   */
+  forget(event: string): void;
+  /**
+   * Clear all queued events
+   */
+  forgetPushed(): void;
+  /**
+   * Get raw listener mappings
+   *
+   * @returns Map of event names to their listeners
+   */
+  getRawListeners(): Map<string, EventListener[]>;
+}
+//#endregion
+export { DispatcherContract };
+//# sourceMappingURL=Dispatcher.d.cts.map

package/dist/Events/Contracts/Dispatcher.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.cts","names":[],"sources":["../../../src/Events/Contracts/Dispatcher.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;UAAiB,kBAAA;EA2BF;;;;;;;;;;;;;;;;;;EARb,MAAA,CAAO,MAAA,qBAA2B,QAAA,EAAU,aAAA;EAoGrC;;;;;;EA5FP,YAAA,CAAa,SAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBb,SAAA,CAAU,UAAA,EAAY,eAAA;;;;;;;;;;;;;;;;;;;;;EAsBtB,QAAA,CAAS,KAAA,WAAgB,KAAA,EAAO,OAAA,UAAiB,IAAA;;;;;;;;;;;;;;;;EAiBjD,KAAA,CAAM,KAAA,WAAgB,KAAA,EAAO,OAAA;;;;;;;;;;;;;;EAe7B,IAAA,CAAK,KAAA,UAAe,OAAA;;;;;;EAOpB,KAAA,CAAM,KAAA;;;;;;EAON,MAAA,CAAO,KAAA;;;;EAKP,YAAA;;;;;;EAOA,eAAA,IAAmB,GAAA,SAAY,aAAA;AAAA"}

package/dist/Events/Contracts/Dispatcher.d.mts

@@ -0,0 +1,148 @@
+import { Event } from "../Event.mjs";
+import { EventListener, EventSubscriber } from "../types.mjs";
+
+//#region src/Events/Contracts/Dispatcher.d.ts
+/**
+ * Event Dispatcher Contract
+ *
+ * Defines the interface for the event dispatcher service.
+ * The dispatcher manages event listeners and dispatches events to them.
+ *
+ * @example
+ * ```typescript
+ * const dispatcher = app.make<DispatcherContract>('events');
+ *
+ * // Register a listener
+ * dispatcher.listen(UserRegistered, SendWelcomeEmail);
+ *
+ * // Dispatch an event
+ * dispatcher.dispatch(new UserRegistered(user));
+ * ```
+ */
+interface DispatcherContract {
+  /**
+   * Register an event listener
+   *
+   * @param events - Event name(s) to listen for
+   * @param listener - Listener to invoke when event is dispatched
+   *
+   * @example
+   * ```typescript
+   * // Single event
+   * dispatcher.listen('user.registered', SendWelcomeEmail);
+   *
+   * // Multiple events
+   * dispatcher.listen(['user.registered', 'user.updated'], LogUserActivity);
+   *
+   * // Wildcard
+   * dispatcher.listen('user.*', LogAllUserEvents);
+   * ```
+   */
+  listen(events: string | string[], listener: EventListener): void;
+  /**
+   * Check if an event has any listeners
+   *
+   * @param eventName - The event name to check
+   * @returns True if the event has listeners
+   */
+  hasListeners(eventName: string): boolean;
+  /**
+   * Register an event subscriber
+   *
+   * Subscribers can register multiple event listeners at once
+   *
+   * @param subscriber - The subscriber instance
+   *
+   * @example
+   * ```typescript
+   * class UserEventSubscriber implements EventSubscriber {
+   *   subscribe(events: DispatcherContract) {
+   *     events.listen('user.registered', this.onRegistered.bind(this));
+   *     events.listen('user.updated', this.onUpdated.bind(this));
+   *   }
+   *
+   *   onRegistered(event: UserRegistered) { }
+   *   onUpdated(event: UserUpdated) { }
+   * }
+   *
+   * dispatcher.subscribe(new UserEventSubscriber());
+   * ```
+   */
+  subscribe(subscriber: EventSubscriber): void;
+  /**
+   * Dispatch an event to all listeners
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @param halt - Stop dispatching if a listener returns false
+   * @returns Array of results from listeners
+   *
+   * @example
+   * ```typescript
+   * // Dispatch with event instance
+   * dispatcher.dispatch(new UserRegistered(user));
+   *
+   * // Dispatch with event name and payload
+   * dispatcher.dispatch('user.registered', [user]);
+   *
+   * // Halt on first false return
+   * dispatcher.dispatch(new OrderProcessing(order), [], true);
+   * ```
+   */
+  dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+  /**
+   * Dispatch an event until a listener returns a non-null response
+   *
+   * This is useful for events where you want the first "truthy" response
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @returns The first non-null response from a listener
+   *
+   * @example
+   * ```typescript
+   * // Get the first validation result
+   * const isValid = dispatcher.until(new ValidateOrder(order));
+   * ```
+   */
+  until(event: string | Event, payload?: any[]): any;
+  /**
+   * Queue an event for later dispatch
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   *
+   * @example
+   * ```typescript
+   * dispatcher.push('send.notification', [user, message]);
+   * // Later...
+   * dispatcher.flush('send.notification');
+   * ```
+   */
+  push(event: string, payload?: any[]): void;
+  /**
+   * Flush (dispatch) all queued events for a specific event name
+   *
+   * @param event - Event name to flush
+   */
+  flush(event: string): void;
+  /**
+   * Remove all listeners for an event
+   *
+   * @param event - Event name
+   */
+  forget(event: string): void;
+  /**
+   * Clear all queued events
+   */
+  forgetPushed(): void;
+  /**
+   * Get raw listener mappings
+   *
+   * @returns Map of event names to their listeners
+   */
+  getRawListeners(): Map<string, EventListener[]>;
+}
+//#endregion
+export { DispatcherContract };
+//# sourceMappingURL=Dispatcher.d.mts.map

package/dist/Events/Contracts/Dispatcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.mts","names":[],"sources":["../../../src/Events/Contracts/Dispatcher.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;UAAiB,kBAAA;EA2BF;;;;;;;;;;;;;;;;;;EARb,MAAA,CAAO,MAAA,qBAA2B,QAAA,EAAU,aAAA;EAoGrC;;;;;;EA5FP,YAAA,CAAa,SAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBb,SAAA,CAAU,UAAA,EAAY,eAAA;;;;;;;;;;;;;;;;;;;;;EAsBtB,QAAA,CAAS,KAAA,WAAgB,KAAA,EAAO,OAAA,UAAiB,IAAA;;;;;;;;;;;;;;;;EAiBjD,KAAA,CAAM,KAAA,WAAgB,KAAA,EAAO,OAAA;;;;;;;;;;;;;;EAe7B,IAAA,CAAK,KAAA,UAAe,OAAA;;;;;;EAOpB,KAAA,CAAM,KAAA;;;;;;EAON,MAAA,CAAO,KAAA;;;;EAKP,YAAA;;;;;;EAOA,eAAA,IAAmB,GAAA,SAAY,aAAA;AAAA"}

package/dist/Events/Dispatcher.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);var e=class{listeners=new Map;wildcards=new Map;queuedEvents=new Map;constructor(e){this.container=e}listen(e,t){let n=Array.isArray(e)?e:[e];for(let e of n)e.includes(`*`)?this.setupWildcardListen(e,t):(this.listeners.has(e)||this.listeners.set(e,[]),this.listeners.get(e).push(t))}hasListeners(e){return this.getListeners(e).length>0}subscribe(e){let t=e.subscribe(this);if(t&&typeof t==`object`)for(let[e,n]of Object.entries(t)){let t=Array.isArray(n)?n:[n];for(let n of t)this.listen(e,n)}}dispatch(e,t=[],n=!1){let[r,i]=this.parseEventAndPayload(e,t);i&&this.shouldBroadcast(i,t);let a=this.getListeners(r),o=[];for(let e of a){let a=this.callListener(e,i||r,t);if(n&&a===!1)return o;a!=null&&o.push(a)}return o}until(e,t=[]){let[n,r]=this.parseEventAndPayload(e,t),i=this.getListeners(n);for(let e of i){let i=this.callListener(e,r||n,t);if(i!=null)return i}return null}push(e,t=[]){this.queuedEvents.has(e)||this.queuedEvents.set(e,[]),this.queuedEvents.get(e).push({payload:t})}flush(e){let t=this.queuedEvents.get(e);if(!(!t||t.length===0)){for(let{payload:n}of t)this.dispatch(e,n);this.queuedEvents.delete(e)}}forget(e){this.listeners.delete(e),this.wildcards.delete(e)}forgetPushed(){this.queuedEvents.clear()}getRawListeners(){return this.listeners}getListeners(e){let t=this.listeners.get(e)||[],n=this.getWildcardListeners(e);return[...t,...n]}setupWildcardListen(e,t){this.wildcards.has(e)||this.wildcards.set(e,[]),this.wildcards.get(e).push(t)}getWildcardListeners(e){let t=[];for(let[n,r]of this.wildcards)this.wildcardMatch(n,e)&&t.push(...r);return t}wildcardMatch(e,t){let n=e.replace(/[.+?^${}()|[\]\\]/g,`\\$&`).replace(/\*/g,`.*`);return RegExp(`^${n}$`).test(t)}parseEventAndPayload(e,t){return typeof e==`string`?[e,null]:[e.constructor.name,e]}callListener(e,t,n){try{return this.makeListener(e)(t,...n)}catch(e){throw console.error(`Error calling event listener:`,e),e}}makeListener(e,t=!1){if(typeof e==`string`)return this.createClassListener(e,t);if(typeof e==`function`)return e.prototype&&typeof e.prototype.handle==`function`?(t,...n)=>new e().handle(t):e;if(typeof e==`object`&&`handle`in e){let t=e;return(e,...n)=>t.handle(e)}throw Error(`Invalid listener type: ${typeof e}`)}createClassListener(e,t=!1){return(t,...n)=>{let r=this.container.make(e);if(!r||typeof r.handle!=`function`)throw Error(`Listener [${e}] does not have a handle method`);return r.handle(t)}}shouldBroadcast(e,t){if(typeof e.shouldBroadcast==`function`)return e.shouldBroadcast();if(typeof e.broadcastOn==`function`){let t=e.broadcastOn();return Array.isArray(t)?t.length>0:!!t}return!1}};exports.Dispatcher=e;

package/dist/Events/Dispatcher.d.cts

@@ -0,0 +1,205 @@
+import { Container } from "../Container/Container.cjs";
+import { Event } from "./Event.cjs";
+import { EventListener, EventSubscriber } from "./types.cjs";
+import { DispatcherContract } from "./Contracts/Dispatcher.cjs";
+
+//#region src/Events/Dispatcher.d.ts
+/**
+ * Event Dispatcher
+ *
+ * The core event dispatcher implementation. Manages event listeners,
+ * handles wildcard patterns, and dispatches events to registered listeners.
+ *
+ * @example
+ * ```typescript
+ * const dispatcher = new Dispatcher(container);
+ *
+ * // Register listeners
+ * dispatcher.listen('user.registered', SendWelcomeEmail);
+ * dispatcher.listen('user.*', LogUserActivity);
+ *
+ * // Dispatch events
+ * dispatcher.dispatch(new UserRegistered(user));
+ * ```
+ */
+declare class Dispatcher implements DispatcherContract {
+  protected container: Container;
+  /**
+   * Registered event listeners (direct event name matches)
+   */
+  protected listeners: Map<string, EventListener[]>;
+  /**
+   * Wildcard event listeners (patterns like 'user.*')
+   */
+  protected wildcards: Map<string, EventListener[]>;
+  /**
+   * Queued events waiting to be flushed
+   */
+  protected queuedEvents: Map<string, Array<{
+    payload: any[];
+  }>>;
+  /**
+   * Create a new event dispatcher
+   *
+   * @param container - The service container for resolving listeners
+   */
+  constructor(container: Container);
+  /**
+   * Register an event listener
+   *
+   * Supports single events, multiple events, and wildcard patterns
+   *
+   * @param events - Event name(s) to listen for
+   * @param listener - Listener to invoke when event is dispatched
+   */
+  listen(events: string | string[], listener: EventListener): void;
+  /**
+   * Check if an event has any listeners
+   *
+   * Checks both direct listeners and wildcard matches
+   *
+   * @param eventName - The event name to check
+   * @returns True if the event has listeners
+   */
+  hasListeners(eventName: string): boolean;
+  /**
+   * Register an event subscriber
+   *
+   * Subscribers can register multiple event listeners at once
+   *
+   * @param subscriber - The subscriber instance
+   */
+  subscribe(subscriber: EventSubscriber): void;
+  /**
+   * Dispatch an event to all listeners
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @param halt - Stop dispatching if a listener returns false
+   * @returns Array of results from listeners
+   */
+  dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+  /**
+   * Dispatch an event until a listener returns a non-null response
+   *
+   * @param event - Event name or instance
+   * @param payload - Additional arguments to pass to listeners
+   * @returns The first non-null response from a listener
+   */
+  until(event: string | Event, payload?: any[]): any;
+  /**
+   * Queue an event for later dispatch
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   */
+  push(event: string, payload?: any[]): void;
+  /**
+   * Flush (dispatch) all queued events for a specific event name
+   *
+   * @param event - Event name to flush
+   */
+  flush(event: string): void;
+  /**
+   * Remove all listeners for an event
+   *
+   * @param event - Event name
+   */
+  forget(event: string): void;
+  /**
+   * Clear all queued events
+   */
+  forgetPushed(): void;
+  /**
+   * Get raw listener mappings
+   *
+   * @returns Map of event names to their listeners
+   */
+  getRawListeners(): Map<string, EventListener[]>;
+  /**
+   * Get all listeners for an event (direct + wildcard matches)
+   *
+   * @param eventName - The event name
+   * @returns Array of listeners
+   */
+  protected getListeners(eventName: string): EventListener[];
+  /**
+   * Setup a wildcard listener
+   *
+   * @param event - Wildcard pattern (e.g., 'user.*')
+   * @param listener - Listener to invoke
+   */
+  protected setupWildcardListen(event: string, listener: EventListener): void;
+  /**
+   * Get all wildcard listeners matching an event name
+   *
+   * @param eventName - The event name to match
+   * @returns Array of matching listeners
+   */
+  protected getWildcardListeners(eventName: string): EventListener[];
+  /**
+   * Check if an event name matches a wildcard pattern
+   *
+   * Supports patterns like:
+   * - 'event.*' - Matches 'event.created', 'event.updated', etc.
+   * - 'event.*.action' - Matches 'event.user.action', 'event.post.action', etc.
+   * - '*' - Matches everything
+   *
+   * @param pattern - Wildcard pattern
+   * @param eventName - Event name to test
+   * @returns True if the pattern matches
+   */
+  protected wildcardMatch(pattern: string, eventName: string): boolean;
+  /**
+   * Parse event and payload from dispatch arguments
+   *
+   * @param event - Event name or instance
+   * @param payload - Event payload
+   * @returns Tuple of [eventName, eventInstance]
+   */
+  protected parseEventAndPayload(event: string | Event, payload: any[]): [string, Event | null];
+  /**
+   * Call a listener with the event and payload
+   *
+   * Handles different listener types (closure, class instance, string reference)
+   *
+   * @param listener - The listener to call
+   * @param event - Event name or instance
+   * @param payload - Additional payload arguments
+   * @returns The result from the listener
+   */
+  protected callListener(listener: EventListener, event: string | Event, payload: any[]): any;
+  /**
+   * Create a callable function from a listener
+   *
+   * Resolves string listeners from container and wraps class instances
+   *
+   * @param listener - The listener to convert
+   * @param wildcard - Whether this is for a wildcard listener
+   * @returns Callable function
+   */
+  protected makeListener(listener: EventListener, wildcard?: boolean): (...args: any[]) => any;
+  /**
+   * Create a listener from a class string reference
+   *
+   * Resolves the class from the container and calls its handle method
+   *
+   * @param listener - Class name/path to resolve
+   * @param wildcard - Whether this is for a wildcard listener
+   * @returns Callable function
+   */
+  protected createClassListener(listener: string, wildcard?: boolean): (...args: any[]) => any;
+  /**
+   * Check if an event should broadcast
+   *
+   * This is a placeholder for future broadcasting support
+   *
+   * @param event - The event instance
+   * @param payload - The event payload
+   * @returns True if should broadcast
+   */
+  protected shouldBroadcast(event: Event, payload: any[]): boolean;
+}
+//#endregion
+export { Dispatcher };
+//# sourceMappingURL=Dispatcher.d.cts.map

package/dist/Events/Dispatcher.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.cts","names":[],"sources":["../../src/Events/Dispatcher.ts"],"mappings":";;;;;;;;AAuBA;;;;;;;;;;;;;;;;cAAa,UAAA,YAAsB,kBAAA;EAAA,UAqBX,SAAA,EAAW,SAAA;EAqMsB;;;EAAA,UAtN7C,SAAA,EAAW,GAAA,SAAY,aAAA;EA+RA;;;EAAA,UA1RvB,SAAA,EAAW,GAAA,SAAY,aAAA;EATA;;;EAAA,UAcvB,YAAA,EAAc,GAAA,SAAY,KAAA;IAAQ,OAAA;EAAA;EAVlC;;;;;cAiBY,SAAA,EAAW,SAAA;EAPvB;;;;;;;;EAiBV,MAAA,CAAO,MAAA,qBAA2B,QAAA,EAAU,aAAA;EAAA;;;;;;;;EAuB5C,YAAA,CAAa,SAAA;EAkCJ;;;;;;;EAvBT,SAAA,CAAU,UAAA,EAAY,eAAA;EA+EjB;;;;;;;;EAxDL,QAAA,CAAS,KAAA,WAAgB,KAAA,EAAO,OAAA,UAAqB,IAAA;EA2GtB;;;;;;;EAxE/B,KAAA,CAAM,KAAA,WAAgB,KAAA,EAAO,OAAA;EA6GnB;;;;;;EAxFV,IAAA,CAAK,KAAA,UAAe,OAAA;EAgI2B;;;;;EAnH/C,KAAA,CAAM,KAAA;EAsIiB;;;;;EAjHvB,MAAA,CAAO,KAAA;EAqIgB;;;EA7HvB,YAAA,CAAA;EAsK8B;;;;;EA7J9B,eAAA,CAAA,GAAmB,GAAA,SAAY,aAAA;EAoLS;;;;;;EAAA,UA1K9B,YAAA,CAAa,SAAA,WAAoB,aAAA;;;;;;;YAajC,mBAAA,CAAoB,KAAA,UAAe,QAAA,EAAU,aAAA;;;;;;;YAc7C,oBAAA,CAAqB,SAAA,WAAoB,aAAA;;;;;;;;;;;;;YAwBzC,aAAA,CAAc,OAAA,UAAiB,SAAA;;;;;;;;YAgB/B,oBAAA,CAAqB,KAAA,WAAgB,KAAA,EAAO,OAAA,mBAA0B,KAAA;;;;;;;;;;;YAmBtE,YAAA,CAAa,QAAA,EAAU,aAAA,EAAe,KAAA,WAAgB,KAAA,EAAO,OAAA;;;;;;;;;;YAoB7D,YAAA,CAAa,QAAA,EAAU,aAAA,EAAe,QAAA,iBAAgC,IAAA;;;;;;;;;;YAyCtE,mBAAA,CAAoB,QAAA,UAAkB,QAAA,iBAAgC,IAAA;;;;;;;;;;YAuBtE,eAAA,CAAgB,KAAA,EAAO,KAAA,EAAO,OAAA;AAAA"}