@orchestr-sh/orchestr 1.10.0 → 1.11.0

package/dist/Events/Dispatcher.d.mts

@@ -0,0 +1,205 @@
+import { Container } from "../Container/Container.mjs";
+import { Event } from "./Event.mjs";
+import { EventListener, EventSubscriber } from "./types.mjs";
+import { DispatcherContract } from "./Contracts/Dispatcher.mjs";
+
+//#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.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.mts","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"}

package/dist/Events/Dispatcher.mjs

@@ -0,0 +1,2 @@
+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}};export{e as Dispatcher};
+//# sourceMappingURL=Dispatcher.mjs.map

package/dist/Events/Dispatcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.mjs","names":[],"sources":["../../src/Events/Dispatcher.ts"],"sourcesContent":["import type { Container } from '@/Container/Container';\nimport type { DispatcherContract } from './Contracts/Dispatcher';\nimport type { Event } from './Event';\nimport type { EventListener, EventSubscriber, ListenerInterface } from './types';\n\n/**\n * Event Dispatcher\n *\n * The core event dispatcher implementation. Manages event listeners,\n * handles wildcard patterns, and dispatches events to registered listeners.\n *\n * @example\n * ```typescript\n * const dispatcher = new Dispatcher(container);\n *\n * // Register listeners\n * dispatcher.listen('user.registered', SendWelcomeEmail);\n * dispatcher.listen('user.*', LogUserActivity);\n *\n * // Dispatch events\n * dispatcher.dispatch(new UserRegistered(user));\n * ```\n */\nexport class Dispatcher implements DispatcherContract {\n  /**\n   * Registered event listeners (direct event name matches)\n   */\n  protected listeners: Map<string, EventListener[]> = new Map();\n\n  /**\n   * Wildcard event listeners (patterns like 'user.*')\n   */\n  protected wildcards: Map<string, EventListener[]> = new Map();\n\n  /**\n   * Queued events waiting to be flushed\n   */\n  protected queuedEvents: Map<string, Array<{ payload: any[] }>> = new Map();\n\n  /**\n   * Create a new event dispatcher\n   *\n   * @param container - The service container for resolving listeners\n   */\n  constructor(protected container: Container) {}\n\n  /**\n   * Register an event listener\n   *\n   * Supports single events, multiple events, and wildcard patterns\n   *\n   * @param events - Event name(s) to listen for\n   * @param listener - Listener to invoke when event is dispatched\n   */\n  listen(events: string | string[], listener: EventListener): void {\n    const eventArray = Array.isArray(events) ? events : [events];\n\n    for (const event of eventArray) {\n      if (event.includes('*')) {\n        this.setupWildcardListen(event, listener);\n      } else {\n        if (!this.listeners.has(event)) {\n          this.listeners.set(event, []);\n        }\n        this.listeners.get(event)!.push(listener);\n      }\n    }\n  }\n\n  /**\n   * Check if an event has any listeners\n   *\n   * Checks both direct listeners and wildcard matches\n   *\n   * @param eventName - The event name to check\n   * @returns True if the event has listeners\n   */\n  hasListeners(eventName: string): boolean {\n    return this.getListeners(eventName).length > 0;\n  }\n\n  /**\n   * Register an event subscriber\n   *\n   * Subscribers can register multiple event listeners at once\n   *\n   * @param subscriber - The subscriber instance\n   */\n  subscribe(subscriber: EventSubscriber): void {\n    const result = subscriber.subscribe(this);\n\n    // If the subscriber returns a mapping, register those listeners\n    if (result && typeof result === 'object') {\n      for (const [event, listeners] of Object.entries(result)) {\n        const listenerArray = Array.isArray(listeners) ? listeners : [listeners];\n\n        for (const listener of listenerArray) {\n          this.listen(event, listener);\n        }\n      }\n    }\n  }\n\n  /**\n   * Dispatch an event to all listeners\n   *\n   * @param event - Event name or instance\n   * @param payload - Additional arguments to pass to listeners\n   * @param halt - Stop dispatching if a listener returns false\n   * @returns Array of results from listeners\n   */\n  dispatch(event: string | Event, payload: any[] = [], halt: boolean = false): any[] {\n    const [eventName, eventInstance] = this.parseEventAndPayload(event, payload);\n\n    // Check if we should broadcast this event (for future broadcasting support)\n    if (eventInstance) {\n      this.shouldBroadcast(eventInstance, payload);\n    }\n\n    const listeners = this.getListeners(eventName);\n    const responses: any[] = [];\n\n    for (const listener of listeners) {\n      const response = this.callListener(listener, eventInstance || eventName, payload);\n\n      // If halting and response is false, stop propagation\n      if (halt && response === false) {\n        return responses;\n      }\n\n      // Collect non-null responses\n      if (response !== null && response !== undefined) {\n        responses.push(response);\n      }\n    }\n\n    return responses;\n  }\n\n  /**\n   * Dispatch an event until a listener returns a non-null response\n   *\n   * @param event - Event name or instance\n   * @param payload - Additional arguments to pass to listeners\n   * @returns The first non-null response from a listener\n   */\n  until(event: string | Event, payload: any[] = []): any {\n    const [eventName, eventInstance] = this.parseEventAndPayload(event, payload);\n    const listeners = this.getListeners(eventName);\n\n    for (const listener of listeners) {\n      const response = this.callListener(listener, eventInstance || eventName, payload);\n\n      if (response !== null && response !== undefined) {\n        return response;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Queue an event for later dispatch\n   *\n   * @param event - Event name\n   * @param payload - Event payload\n   */\n  push(event: string, payload: any[] = []): void {\n    if (!this.queuedEvents.has(event)) {\n      this.queuedEvents.set(event, []);\n    }\n\n    this.queuedEvents.get(event)!.push({ payload });\n  }\n\n  /**\n   * Flush (dispatch) all queued events for a specific event name\n   *\n   * @param event - Event name to flush\n   */\n  flush(event: string): void {\n    const queued = this.queuedEvents.get(event);\n\n    if (!queued || queued.length === 0) {\n      return;\n    }\n\n    // Dispatch each queued event\n    for (const { payload } of queued) {\n      this.dispatch(event, payload);\n    }\n\n    // Clear the queue for this event\n    this.queuedEvents.delete(event);\n  }\n\n  /**\n   * Remove all listeners for an event\n   *\n   * @param event - Event name\n   */\n  forget(event: string): void {\n    this.listeners.delete(event);\n    this.wildcards.delete(event);\n  }\n\n  /**\n   * Clear all queued events\n   */\n  forgetPushed(): void {\n    this.queuedEvents.clear();\n  }\n\n  /**\n   * Get raw listener mappings\n   *\n   * @returns Map of event names to their listeners\n   */\n  getRawListeners(): Map<string, EventListener[]> {\n    return this.listeners;\n  }\n\n  /**\n   * Get all listeners for an event (direct + wildcard matches)\n   *\n   * @param eventName - The event name\n   * @returns Array of listeners\n   */\n  protected getListeners(eventName: string): EventListener[] {\n    const directListeners = this.listeners.get(eventName) || [];\n    const wildcardListeners = this.getWildcardListeners(eventName);\n\n    return [...directListeners, ...wildcardListeners];\n  }\n\n  /**\n   * Setup a wildcard listener\n   *\n   * @param event - Wildcard pattern (e.g., 'user.*')\n   * @param listener - Listener to invoke\n   */\n  protected setupWildcardListen(event: string, listener: EventListener): void {\n    if (!this.wildcards.has(event)) {\n      this.wildcards.set(event, []);\n    }\n\n    this.wildcards.get(event)!.push(listener);\n  }\n\n  /**\n   * Get all wildcard listeners matching an event name\n   *\n   * @param eventName - The event name to match\n   * @returns Array of matching listeners\n   */\n  protected getWildcardListeners(eventName: string): EventListener[] {\n    const matched: EventListener[] = [];\n\n    for (const [pattern, listeners] of this.wildcards) {\n      if (this.wildcardMatch(pattern, eventName)) {\n        matched.push(...listeners);\n      }\n    }\n\n    return matched;\n  }\n\n  /**\n   * Check if an event name matches a wildcard pattern\n   *\n   * Supports patterns like:\n   * - 'event.*' - Matches 'event.created', 'event.updated', etc.\n   * - 'event.*.action' - Matches 'event.user.action', 'event.post.action', etc.\n   * - '*' - Matches everything\n   *\n   * @param pattern - Wildcard pattern\n   * @param eventName - Event name to test\n   * @returns True if the pattern matches\n   */\n  protected wildcardMatch(pattern: string, eventName: string): boolean {\n    // Convert wildcard pattern to regex\n    // Escape special regex characters except *\n    const regexPattern = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\*/g, '.*');\n\n    const regex = new RegExp(`^${regexPattern}$`);\n    return regex.test(eventName);\n  }\n\n  /**\n   * Parse event and payload from dispatch arguments\n   *\n   * @param event - Event name or instance\n   * @param payload - Event payload\n   * @returns Tuple of [eventName, eventInstance]\n   */\n  protected parseEventAndPayload(event: string | Event, payload: any[]): [string, Event | null] {\n    if (typeof event === 'string') {\n      return [event, null];\n    }\n\n    // Event is an object\n    return [event.constructor.name, event];\n  }\n\n  /**\n   * Call a listener with the event and payload\n   *\n   * Handles different listener types (closure, class instance, string reference)\n   *\n   * @param listener - The listener to call\n   * @param event - Event name or instance\n   * @param payload - Additional payload arguments\n   * @returns The result from the listener\n   */\n  protected callListener(listener: EventListener, event: string | Event, payload: any[]): any {\n    try {\n      const callable = this.makeListener(listener);\n      return callable(event, ...payload);\n    } catch (error) {\n      // Re-throw the error to allow application-level error handling\n      console.error(`Error calling event listener:`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Create a callable function from a listener\n   *\n   * Resolves string listeners from container and wraps class instances\n   *\n   * @param listener - The listener to convert\n   * @param wildcard - Whether this is for a wildcard listener\n   * @returns Callable function\n   */\n  protected makeListener(listener: EventListener, wildcard: boolean = false): (...args: any[]) => any {\n    // If it's a string, resolve from container\n    if (typeof listener === 'string') {\n      return this.createClassListener(listener, wildcard);\n    }\n\n    // If it's a function/class constructor\n    if (typeof listener === 'function') {\n      // Check if it's a class constructor (has prototype with handle method)\n      if (listener.prototype && typeof listener.prototype.handle === 'function') {\n        // It's a class constructor, instantiate and call handle\n        return (event: Event, ...payload: any[]) => {\n          const instance = new (listener as any)();\n          return instance.handle(event);\n        };\n      }\n\n      // It's a regular function (closure), return as-is\n      return listener;\n    }\n\n    // If it's a class instance with handle method\n    if (typeof listener === 'object' && 'handle' in listener) {\n      const instance = listener as ListenerInterface;\n      return (event: Event, ...payload: any[]) => {\n        return instance.handle(event);\n      };\n    }\n\n    throw new Error(`Invalid listener type: ${typeof listener}`);\n  }\n\n  /**\n   * Create a listener from a class string reference\n   *\n   * Resolves the class from the container and calls its handle method\n   *\n   * @param listener - Class name/path to resolve\n   * @param wildcard - Whether this is for a wildcard listener\n   * @returns Callable function\n   */\n  protected createClassListener(listener: string, wildcard: boolean = false): (...args: any[]) => any {\n    return (event: Event, ...payload: any[]) => {\n      // Resolve the listener class from the container\n      const instance = this.container.make<ListenerInterface>(listener);\n\n      if (!instance || typeof instance.handle !== 'function') {\n        throw new Error(`Listener [${listener}] does not have a handle method`);\n      }\n\n      // Call the handle method\n      return instance.handle(event);\n    };\n  }\n\n  /**\n   * Check if an event should broadcast\n   *\n   * This is a placeholder for future broadcasting support\n   *\n   * @param event - The event instance\n   * @param payload - The event payload\n   * @returns True if should broadcast\n   */\n  protected shouldBroadcast(event: Event, payload: any[]): boolean {\n    // Check if event has shouldBroadcast method and it returns true\n    if (typeof (event as any).shouldBroadcast === 'function') {\n      return (event as any).shouldBroadcast();\n    }\n\n    // Check if event has broadcastOn method that returns channels\n    if (typeof (event as any).broadcastOn === 'function') {\n      const channels = (event as any).broadcastOn();\n      return Array.isArray(channels) ? channels.length > 0 : !!channels;\n    }\n\n    return false;\n  }\n}\n"],"mappings":"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"}

package/dist/Events/Event.cjs

@@ -0,0 +1 @@
+require(`../_virtual/_rolldown/runtime.cjs`);const e=require(`./Concerns/Dispatchable.cjs`);var t=class{static serializable=[];connection;queue;delay;toJSON(){let e={_class:this.constructor.name},t=this.constructor,n=Object.getOwnPropertyNames(this);for(let r of n){if(t.serializable.includes(r)||r.startsWith(`_`))continue;let n=this[r];n!==void 0&&(e[r]=this.serializeValue(n))}return e}serializeValue(e){if(e==null)return e;if(e instanceof Date)return{_type:`Date`,value:e.toISOString()};if(typeof e==`object`&&typeof e.toJSON==`function`)return e.toJSON();if(Array.isArray(e))return e.map(e=>this.serializeValue(e));if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=this.serializeValue(r);return t}return e}static fromJSON(e){let t=Object.create(this.prototype);for(let[n,r]of Object.entries(e))n!==`_class`&&(t[n]=this.deserializeValue(r));return t}static deserializeValue(e){if(e==null)return e;if(typeof e==`object`&&e._type)switch(e._type){case`Date`:return new Date(e.value);default:return e}if(Array.isArray(e))return e.map(e=>this.deserializeValue(e));if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=this.deserializeValue(r);return t}return e}broadcastOn(){return[]}broadcastWith(){let e={},t=Object.getOwnPropertyNames(this);for(let n of t){if(n.startsWith(`_`)||[`connection`,`queue`,`delay`].includes(n))continue;let t=this[n];t!==void 0&&(e[n]=t)}return e}broadcastAs(){return this.constructor.name}shouldBroadcast(){let e=this.broadcastOn();return Array.isArray(e)?e.length>0:!!e}};e.applyDispatchable(t),exports.Event=t;

package/dist/Events/Event.d.cts

@@ -0,0 +1,167 @@
+//#region src/Events/Event.d.ts
+/**
+ * Event Base Class
+ *
+ * Base class for all events in the application
+ * Provides serialization support and broadcasting capabilities
+ *
+ * @example
+ * ```typescript
+ * class UserRegistered extends Event {
+ *   constructor(public readonly user: User) {
+ *     super();
+ *   }
+ * }
+ *
+ * // Dispatch the event
+ * UserRegistered.dispatch(user);
+ * ```
+ */
+/**
+ * Abstract Event base class
+ *
+ * All application events should extend this class.
+ * It provides:
+ * - Event metadata storage
+ * - Serialization for queueing
+ * - Broadcasting support
+ * - Static dispatch methods (via Dispatchable mixin)
+ */
+declare abstract class Event {
+  /**
+   * Properties to exclude from serialization
+   * Override in child classes to specify which properties should not be serialized
+   */
+  protected static serializable: string[];
+  /**
+   * The name of the connection the job should be sent to
+   * Used when queueing event listeners
+   */
+  connection?: string;
+  /**
+   * The name of the queue the job should be sent to
+   * Used when queueing event listeners
+   */
+  queue?: string;
+  /**
+   * The number of seconds before the job should be processed
+   * Used when queueing event listeners
+   */
+  delay?: number;
+  /**
+   * Convert event to JSON for queue serialization
+   *
+   * Serializes all public properties except those listed in the serializable array
+   *
+   * @returns Object representation of the event
+   */
+  toJSON(): Record<string, any>;
+  /**
+   * Serialize a value for JSON storage
+   *
+   * @param value - Value to serialize
+   * @returns Serialized value
+   */
+  protected serializeValue(value: any): any;
+  /**
+   * Recreate event from JSON
+   *
+   * This method should be overridden in child classes if custom deserialization is needed
+   *
+   * @param data - Serialized event data
+   * @returns Event instance
+   */
+  static fromJSON<T extends Event>(this: typeof Event & (new (...args: any[]) => T), data: Record<string, any>): T;
+  /**
+   * Deserialize a value from JSON
+   *
+   * @param value - Serialized value
+   * @returns Deserialized value
+   */
+  protected static deserializeValue(value: any): any;
+  /**
+   * Get the broadcast channel name(s)
+   *
+   * Override in child classes to specify which channels this event should broadcast on
+   *
+   * @returns Channel name(s) or empty array for no broadcasting
+   *
+   * @example
+   * ```typescript
+   * broadcastOn(): string | string[] {
+   *   return 'users.' + this.user.id;
+   * }
+   * ```
+   */
+  broadcastOn(): string | string[];
+  /**
+   * Get the data to broadcast
+   *
+   * Override in child classes to customize the broadcast payload
+   * By default, returns all public properties
+   *
+   * @returns Data to broadcast
+   *
+   * @example
+   * ```typescript
+   * broadcastWith(): Record<string, any> {
+   *   return {
+   *     userId: this.user.id,
+   *     userName: this.user.name,
+   *   };
+   * }
+   * ```
+   */
+  broadcastWith(): Record<string, any>;
+  /**
+   * Get the broadcast event name
+   *
+   * Override in child classes to customize the event name sent to clients
+   * By default, returns the class name
+   *
+   * @returns Event name for broadcasting
+   *
+   * @example
+   * ```typescript
+   * broadcastAs(): string {
+   *   return 'user.registered';
+   * }
+   * ```
+   */
+  broadcastAs(): string;
+  /**
+   * Determine if this event should broadcast
+   *
+   * Override in child classes to conditionally broadcast events
+   *
+   * @returns True if event should broadcast
+   */
+  shouldBroadcast(): boolean;
+}
+/**
+ * Type helper for Event classes with static dispatch methods
+ *
+ * Use this to get proper typing for your event classes:
+ * @example
+ * ```typescript
+ * class UserRegistered extends Event {
+ *   constructor(public user: User) {
+ *     super();
+ *   }
+ * }
+ *
+ * // TypeScript will recognize these:
+ * UserRegistered.dispatch(user);
+ * UserRegistered.dispatchIf(condition, user);
+ * ```
+ */
+type EventClass<T extends Event = Event> = typeof Event & {
+  new (...args: any[]): T;
+  dispatch(...args: any[]): any[];
+  dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[];
+  dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[];
+  until(...args: any[]): any;
+};
+//#endregion
+export { Event, EventClass };
+//# sourceMappingURL=Event.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.cts","names":[],"sources":["../../src/Events/Event.ts"],"mappings":";;AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAsB,KAAA;EAqH+D;;;;EAAA,iBAhHlE,YAAA;EA0MjB;;;;EApMO,UAAA;EAwPQ;AA2BjB;;;EA7QS,KAAA;EA6QgC;;;;EAvQhC,KAAA;EAuQc;;;;;;;EA9PrB,MAAA,CAAA,GAAU,MAAA;EAiQV;;;;;;EAAA,UAzNU,cAAA,CAAe,KAAA;EA2NhB;;;;;;;;EAAA,OA9KF,QAAA,WAAmB,KAAA,CAAA,CAAO,IAAA,SAAa,KAAA,YAAiB,IAAA,YAAgB,CAAA,GAAI,IAAA,EAAM,MAAA,gBAAsB,CAAA;;;;;;;mBAoB9F,gBAAA,CAAiB,KAAA;;;;;;;;;;;;;;;EAgDlC,WAAA,CAAA;;;;;;;;;;;;;;;;;;;EAsBA,aAAA,CAAA,GAAiB,MAAA;;;;;;;;;;;;;;;;EAyCjB,WAAA,CAAA;;;;;;;;EAWA,eAAA,CAAA;AAAA;;;;;;;;;;;;;;;;;;KA2BU,UAAA,WAAqB,KAAA,GAAQ,KAAA,WAAgB,KAAA;EAAA,QAC/C,IAAA,UAAc,CAAA;EACtB,QAAA,IAAY,IAAA;EACZ,UAAA,CAAW,SAAA,gCAAyC,IAAA;EACpD,cAAA,CAAe,SAAA,gCAAyC,IAAA;EACxD,KAAA,IAAS,IAAA;AAAA"}

package/dist/Events/Event.d.mts

@@ -0,0 +1,167 @@
+//#region src/Events/Event.d.ts
+/**
+ * Event Base Class
+ *
+ * Base class for all events in the application
+ * Provides serialization support and broadcasting capabilities
+ *
+ * @example
+ * ```typescript
+ * class UserRegistered extends Event {
+ *   constructor(public readonly user: User) {
+ *     super();
+ *   }
+ * }
+ *
+ * // Dispatch the event
+ * UserRegistered.dispatch(user);
+ * ```
+ */
+/**
+ * Abstract Event base class
+ *
+ * All application events should extend this class.
+ * It provides:
+ * - Event metadata storage
+ * - Serialization for queueing
+ * - Broadcasting support
+ * - Static dispatch methods (via Dispatchable mixin)
+ */
+declare abstract class Event {
+  /**
+   * Properties to exclude from serialization
+   * Override in child classes to specify which properties should not be serialized
+   */
+  protected static serializable: string[];
+  /**
+   * The name of the connection the job should be sent to
+   * Used when queueing event listeners
+   */
+  connection?: string;
+  /**
+   * The name of the queue the job should be sent to
+   * Used when queueing event listeners
+   */
+  queue?: string;
+  /**
+   * The number of seconds before the job should be processed
+   * Used when queueing event listeners
+   */
+  delay?: number;
+  /**
+   * Convert event to JSON for queue serialization
+   *
+   * Serializes all public properties except those listed in the serializable array
+   *
+   * @returns Object representation of the event
+   */
+  toJSON(): Record<string, any>;
+  /**
+   * Serialize a value for JSON storage
+   *
+   * @param value - Value to serialize
+   * @returns Serialized value
+   */
+  protected serializeValue(value: any): any;
+  /**
+   * Recreate event from JSON
+   *
+   * This method should be overridden in child classes if custom deserialization is needed
+   *
+   * @param data - Serialized event data
+   * @returns Event instance
+   */
+  static fromJSON<T extends Event>(this: typeof Event & (new (...args: any[]) => T), data: Record<string, any>): T;
+  /**
+   * Deserialize a value from JSON
+   *
+   * @param value - Serialized value
+   * @returns Deserialized value
+   */
+  protected static deserializeValue(value: any): any;
+  /**
+   * Get the broadcast channel name(s)
+   *
+   * Override in child classes to specify which channels this event should broadcast on
+   *
+   * @returns Channel name(s) or empty array for no broadcasting
+   *
+   * @example
+   * ```typescript
+   * broadcastOn(): string | string[] {
+   *   return 'users.' + this.user.id;
+   * }
+   * ```
+   */
+  broadcastOn(): string | string[];
+  /**
+   * Get the data to broadcast
+   *
+   * Override in child classes to customize the broadcast payload
+   * By default, returns all public properties
+   *
+   * @returns Data to broadcast
+   *
+   * @example
+   * ```typescript
+   * broadcastWith(): Record<string, any> {
+   *   return {
+   *     userId: this.user.id,
+   *     userName: this.user.name,
+   *   };
+   * }
+   * ```
+   */
+  broadcastWith(): Record<string, any>;
+  /**
+   * Get the broadcast event name
+   *
+   * Override in child classes to customize the event name sent to clients
+   * By default, returns the class name
+   *
+   * @returns Event name for broadcasting
+   *
+   * @example
+   * ```typescript
+   * broadcastAs(): string {
+   *   return 'user.registered';
+   * }
+   * ```
+   */
+  broadcastAs(): string;
+  /**
+   * Determine if this event should broadcast
+   *
+   * Override in child classes to conditionally broadcast events
+   *
+   * @returns True if event should broadcast
+   */
+  shouldBroadcast(): boolean;
+}
+/**
+ * Type helper for Event classes with static dispatch methods
+ *
+ * Use this to get proper typing for your event classes:
+ * @example
+ * ```typescript
+ * class UserRegistered extends Event {
+ *   constructor(public user: User) {
+ *     super();
+ *   }
+ * }
+ *
+ * // TypeScript will recognize these:
+ * UserRegistered.dispatch(user);
+ * UserRegistered.dispatchIf(condition, user);
+ * ```
+ */
+type EventClass<T extends Event = Event> = typeof Event & {
+  new (...args: any[]): T;
+  dispatch(...args: any[]): any[];
+  dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[];
+  dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[];
+  until(...args: any[]): any;
+};
+//#endregion
+export { Event, EventClass };
+//# sourceMappingURL=Event.d.mts.map

package/dist/Events/Event.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.mts","names":[],"sources":["../../src/Events/Event.ts"],"mappings":";;AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAsB,KAAA;EAqH+D;;;;EAAA,iBAhHlE,YAAA;EA0MjB;;;;EApMO,UAAA;EAwPQ;AA2BjB;;;EA7QS,KAAA;EA6QgC;;;;EAvQhC,KAAA;EAuQc;;;;;;;EA9PrB,MAAA,CAAA,GAAU,MAAA;EAiQV;;;;;;EAAA,UAzNU,cAAA,CAAe,KAAA;EA2NhB;;;;;;;;EAAA,OA9KF,QAAA,WAAmB,KAAA,CAAA,CAAO,IAAA,SAAa,KAAA,YAAiB,IAAA,YAAgB,CAAA,GAAI,IAAA,EAAM,MAAA,gBAAsB,CAAA;;;;;;;mBAoB9F,gBAAA,CAAiB,KAAA;;;;;;;;;;;;;;;EAgDlC,WAAA,CAAA;;;;;;;;;;;;;;;;;;;EAsBA,aAAA,CAAA,GAAiB,MAAA;;;;;;;;;;;;;;;;EAyCjB,WAAA,CAAA;;;;;;;;EAWA,eAAA,CAAA;AAAA;;;;;;;;;;;;;;;;;;KA2BU,UAAA,WAAqB,KAAA,GAAQ,KAAA,WAAgB,KAAA;EAAA,QAC/C,IAAA,UAAc,CAAA;EACtB,QAAA,IAAY,IAAA;EACZ,UAAA,CAAW,SAAA,gCAAyC,IAAA;EACpD,cAAA,CAAe,SAAA,gCAAyC,IAAA;EACxD,KAAA,IAAS,IAAA;AAAA"}

package/dist/Events/Event.mjs

@@ -0,0 +1,2 @@
+import{applyDispatchable as e}from"./Concerns/Dispatchable.mjs";var t=class{static serializable=[];connection;queue;delay;toJSON(){let e={_class:this.constructor.name},t=this.constructor,n=Object.getOwnPropertyNames(this);for(let r of n){if(t.serializable.includes(r)||r.startsWith(`_`))continue;let n=this[r];n!==void 0&&(e[r]=this.serializeValue(n))}return e}serializeValue(e){if(e==null)return e;if(e instanceof Date)return{_type:`Date`,value:e.toISOString()};if(typeof e==`object`&&typeof e.toJSON==`function`)return e.toJSON();if(Array.isArray(e))return e.map(e=>this.serializeValue(e));if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=this.serializeValue(r);return t}return e}static fromJSON(e){let t=Object.create(this.prototype);for(let[n,r]of Object.entries(e))n!==`_class`&&(t[n]=this.deserializeValue(r));return t}static deserializeValue(e){if(e==null)return e;if(typeof e==`object`&&e._type)switch(e._type){case`Date`:return new Date(e.value);default:return e}if(Array.isArray(e))return e.map(e=>this.deserializeValue(e));if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=this.deserializeValue(r);return t}return e}broadcastOn(){return[]}broadcastWith(){let e={},t=Object.getOwnPropertyNames(this);for(let n of t){if(n.startsWith(`_`)||[`connection`,`queue`,`delay`].includes(n))continue;let t=this[n];t!==void 0&&(e[n]=t)}return e}broadcastAs(){return this.constructor.name}shouldBroadcast(){let e=this.broadcastOn();return Array.isArray(e)?e.length>0:!!e}};e(t);export{t as Event};
+//# sourceMappingURL=Event.mjs.map

package/dist/Events/Event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.mjs","names":[],"sources":["../../src/Events/Event.ts"],"sourcesContent":["/**\n * Event Base Class\n *\n * Base class for all events in the application\n * Provides serialization support and broadcasting capabilities\n *\n * @example\n * ```typescript\n * class UserRegistered extends Event {\n *   constructor(public readonly user: User) {\n *     super();\n *   }\n * }\n *\n * // Dispatch the event\n * UserRegistered.dispatch(user);\n * ```\n */\n\n/**\n * Abstract Event base class\n *\n * All application events should extend this class.\n * It provides:\n * - Event metadata storage\n * - Serialization for queueing\n * - Broadcasting support\n * - Static dispatch methods (via Dispatchable mixin)\n */\nexport abstract class Event {\n  /**\n   * Properties to exclude from serialization\n   * Override in child classes to specify which properties should not be serialized\n   */\n  protected static serializable: string[] = [];\n\n  /**\n   * The name of the connection the job should be sent to\n   * Used when queueing event listeners\n   */\n  public connection?: string;\n\n  /**\n   * The name of the queue the job should be sent to\n   * Used when queueing event listeners\n   */\n  public queue?: string;\n\n  /**\n   * The number of seconds before the job should be processed\n   * Used when queueing event listeners\n   */\n  public delay?: number;\n\n  /**\n   * Convert event to JSON for queue serialization\n   *\n   * Serializes all public properties except those listed in the serializable array\n   *\n   * @returns Object representation of the event\n   */\n  toJSON(): Record<string, any> {\n    const data: Record<string, any> = {\n      _class: this.constructor.name,\n    };\n\n    // Get constructor\n    const ctor = this.constructor as typeof Event;\n\n    // Get all property names\n    const properties = Object.getOwnPropertyNames(this);\n\n    for (const prop of properties) {\n      // Skip if in serializable exclusion list\n      if (ctor.serializable.includes(prop)) {\n        continue;\n      }\n\n      // Skip private properties (starting with _)\n      if (prop.startsWith('_')) {\n        continue;\n      }\n\n      // Get the value\n      const value = (this as any)[prop];\n\n      // Serialize the value\n      if (value !== undefined) {\n        data[prop] = this.serializeValue(value);\n      }\n    }\n\n    return data;\n  }\n\n  /**\n   * Serialize a value for JSON storage\n   *\n   * @param value - Value to serialize\n   * @returns Serialized value\n   */\n  protected serializeValue(value: any): any {\n    // Handle null/undefined\n    if (value === null || value === undefined) {\n      return value;\n    }\n\n    // Handle Date objects\n    if (value instanceof Date) {\n      return {\n        _type: 'Date',\n        value: value.toISOString(),\n      };\n    }\n\n    // Handle objects with toJSON method\n    if (typeof value === 'object' && typeof value.toJSON === 'function') {\n      return value.toJSON();\n    }\n\n    // Handle arrays\n    if (Array.isArray(value)) {\n      return value.map((item) => this.serializeValue(item));\n    }\n\n    // Handle plain objects\n    if (typeof value === 'object') {\n      const serialized: Record<string, any> = {};\n      for (const [key, val] of Object.entries(value)) {\n        serialized[key] = this.serializeValue(val);\n      }\n      return serialized;\n    }\n\n    // Return primitives as-is\n    return value;\n  }\n\n  /**\n   * Recreate event from JSON\n   *\n   * This method should be overridden in child classes if custom deserialization is needed\n   *\n   * @param data - Serialized event data\n   * @returns Event instance\n   */\n  static fromJSON<T extends Event>(this: typeof Event & (new (...args: any[]) => T), data: Record<string, any>): T {\n    // Create a new instance without calling constructor\n    const instance = Object.create(this.prototype);\n\n    // Restore properties\n    for (const [key, value] of Object.entries(data)) {\n      if (key === '_class') continue;\n\n      instance[key] = this.deserializeValue(value);\n    }\n\n    return instance;\n  }\n\n  /**\n   * Deserialize a value from JSON\n   *\n   * @param value - Serialized value\n   * @returns Deserialized value\n   */\n  protected static deserializeValue(value: any): any {\n    // Handle null/undefined\n    if (value === null || value === undefined) {\n      return value;\n    }\n\n    // Handle special type markers\n    if (typeof value === 'object' && value._type) {\n      switch (value._type) {\n        case 'Date':\n          return new Date(value.value);\n        default:\n          return value;\n      }\n    }\n\n    // Handle arrays\n    if (Array.isArray(value)) {\n      return value.map((item) => this.deserializeValue(item));\n    }\n\n    // Handle plain objects\n    if (typeof value === 'object') {\n      const deserialized: Record<string, any> = {};\n      for (const [key, val] of Object.entries(value)) {\n        deserialized[key] = this.deserializeValue(val);\n      }\n      return deserialized;\n    }\n\n    // Return primitives as-is\n    return value;\n  }\n\n  /**\n   * Get the broadcast channel name(s)\n   *\n   * Override in child classes to specify which channels this event should broadcast on\n   *\n   * @returns Channel name(s) or empty array for no broadcasting\n   *\n   * @example\n   * ```typescript\n   * broadcastOn(): string | string[] {\n   *   return 'users.' + this.user.id;\n   * }\n   * ```\n   */\n  broadcastOn(): string | string[] {\n    return [];\n  }\n\n  /**\n   * Get the data to broadcast\n   *\n   * Override in child classes to customize the broadcast payload\n   * By default, returns all public properties\n   *\n   * @returns Data to broadcast\n   *\n   * @example\n   * ```typescript\n   * broadcastWith(): Record<string, any> {\n   *   return {\n   *     userId: this.user.id,\n   *     userName: this.user.name,\n   *   };\n   * }\n   * ```\n   */\n  broadcastWith(): Record<string, any> {\n    const data: Record<string, any> = {};\n\n    // Get all property names\n    const properties = Object.getOwnPropertyNames(this);\n\n    for (const prop of properties) {\n      // Skip private properties\n      if (prop.startsWith('_')) {\n        continue;\n      }\n\n      // Skip queue-related properties\n      if (['connection', 'queue', 'delay'].includes(prop)) {\n        continue;\n      }\n\n      const value = (this as any)[prop];\n      if (value !== undefined) {\n        data[prop] = value;\n      }\n    }\n\n    return data;\n  }\n\n  /**\n   * Get the broadcast event name\n   *\n   * Override in child classes to customize the event name sent to clients\n   * By default, returns the class name\n   *\n   * @returns Event name for broadcasting\n   *\n   * @example\n   * ```typescript\n   * broadcastAs(): string {\n   *   return 'user.registered';\n   * }\n   * ```\n   */\n  broadcastAs(): string {\n    return this.constructor.name;\n  }\n\n  /**\n   * Determine if this event should broadcast\n   *\n   * Override in child classes to conditionally broadcast events\n   *\n   * @returns True if event should broadcast\n   */\n  shouldBroadcast(): boolean {\n    const channels = this.broadcastOn();\n    return Array.isArray(channels) ? channels.length > 0 : !!channels;\n  }\n}\n\n// Apply Dispatchable mixin to Event class\nimport { applyDispatchable } from './Concerns/Dispatchable';\napplyDispatchable(Event);\n\n/**\n * Type helper for Event classes with static dispatch methods\n *\n * Use this to get proper typing for your event classes:\n * @example\n * ```typescript\n * class UserRegistered extends Event {\n *   constructor(public user: User) {\n *     super();\n *   }\n * }\n *\n * // TypeScript will recognize these:\n * UserRegistered.dispatch(user);\n * UserRegistered.dispatchIf(condition, user);\n * ```\n */\nexport type EventClass<T extends Event = Event> = typeof Event & {\n  new (...args: any[]): T;\n  dispatch(...args: any[]): any[];\n  dispatchIf(condition: boolean | (() => boolean), ...args: any[]): any[];\n  dispatchUnless(condition: boolean | (() => boolean), ...args: any[]): any[];\n  until(...args: any[]): any;\n};\n"],"mappings":"gEA6BA,IAAsB,EAAtB,KAA4B,CAK1B,OAAiB,aAAyB,EAAE,CAM5C,WAMA,MAMA,MASA,QAA8B,CAC5B,IAAM,EAA4B,CAChC,OAAQ,KAAK,YAAY,KAC1B,CAGK,EAAO,KAAK,YAGZ,EAAa,OAAO,oBAAoB,KAAK,CAEnD,IAAK,IAAM,KAAQ,EAAY,CAO7B,GALI,EAAK,aAAa,SAAS,EAAK,EAKhC,EAAK,WAAW,IAAI,CACtB,SAIF,IAAM,EAAS,KAAa,GAGxB,IAAU,IAAA,KACZ,EAAK,GAAQ,KAAK,eAAe,EAAM,EAI3C,OAAO,EAST,eAAyB,EAAiB,CAExC,GAAI,GAAU,KACZ,OAAO,EAIT,GAAI,aAAiB,KACnB,MAAO,CACL,MAAO,OACP,MAAO,EAAM,aAAa,CAC3B,CAIH,GAAI,OAAO,GAAU,UAAY,OAAO,EAAM,QAAW,WACvD,OAAO,EAAM,QAAQ,CAIvB,GAAI,MAAM,QAAQ,EAAM,CACtB,OAAO,EAAM,IAAK,GAAS,KAAK,eAAe,EAAK,CAAC,CAIvD,GAAI,OAAO,GAAU,SAAU,CAC7B,IAAM,EAAkC,EAAE,CAC1C,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,EAAM,CAC5C,EAAW,GAAO,KAAK,eAAe,EAAI,CAE5C,OAAO,EAIT,OAAO,EAWT,OAAO,SAA4E,EAA8B,CAE/G,IAAM,EAAW,OAAO,OAAO,KAAK,UAAU,CAG9C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CACzC,IAAQ,WAEZ,EAAS,GAAO,KAAK,iBAAiB,EAAM,EAG9C,OAAO,EAST,OAAiB,iBAAiB,EAAiB,CAEjD,GAAI,GAAU,KACZ,OAAO,EAIT,GAAI,OAAO,GAAU,UAAY,EAAM,MACrC,OAAQ,EAAM,MAAd,CACE,IAAK,OACH,OAAO,IAAI,KAAK,EAAM,MAAM,CAC9B,QACE,OAAO,EAKb,GAAI,MAAM,QAAQ,EAAM,CACtB,OAAO,EAAM,IAAK,GAAS,KAAK,iBAAiB,EAAK,CAAC,CAIzD,GAAI,OAAO,GAAU,SAAU,CAC7B,IAAM,EAAoC,EAAE,CAC5C,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,EAAM,CAC5C,EAAa,GAAO,KAAK,iBAAiB,EAAI,CAEhD,OAAO,EAIT,OAAO,EAiBT,aAAiC,CAC/B,MAAO,EAAE,CAqBX,eAAqC,CACnC,IAAM,EAA4B,EAAE,CAG9B,EAAa,OAAO,oBAAoB,KAAK,CAEnD,IAAK,IAAM,KAAQ,EAAY,CAO7B,GALI,EAAK,WAAW,IAAI,EAKpB,CAAC,aAAc,QAAS,QAAQ,CAAC,SAAS,EAAK,CACjD,SAGF,IAAM,EAAS,KAAa,GACxB,IAAU,IAAA,KACZ,EAAK,GAAQ,GAIjB,OAAO,EAkBT,aAAsB,CACpB,OAAO,KAAK,YAAY,KAU1B,iBAA2B,CACzB,IAAM,EAAW,KAAK,aAAa,CACnC,OAAO,MAAM,QAAQ,EAAS,CAAG,EAAS,OAAS,EAAI,CAAC,CAAC,IAM7D,EAAkB,EAAM"}

package/dist/Events/EventServiceProvider.cjs

@@ -0,0 +1 @@
+const e=require(`../_virtual/_rolldown/runtime.cjs`),t=require(`../Foundation/ServiceProvider.cjs`),n=require(`./Dispatcher.cjs`);let r=require(`fs`);r=e.__toESM(r);var i=class extends t.ServiceProvider{listen={};subscribe=[];register(){this.app.singleton(`events`,e=>new n.Dispatcher(e)),this.app.alias(`events`,n.Dispatcher)}async boot(){let e=this.app.make(`events`);for(let[t,n]of Object.entries(this.listen)){let r=Array.isArray(n)?n:[n];for(let n of r)e.listen(t,n)}for(let t of this.subscribe){let n=this.app.make(t);e.subscribe(n)}this.shouldDiscoverEvents()&&await this.discoverEvents(e)}shouldDiscoverEvents(){return!this.eventsAreCached()}async discoverEvents(e){try{let{EventDiscovery:t}=await Promise.resolve().then(()=>require(`../Support/EventDiscovery.cjs`)),n=await new t(this.app).discover(this.discoverEventsWithin());for(let[t,r]of n)for(let n of r)e.listen(t,n)}catch(e){if(e.code!==`MODULE_NOT_FOUND`)throw e}}discoverEventsWithin(){return this.app.getEventDiscoveryPaths()}eventsAreCached(){let e=this.app.storagePath(`framework/events.json`);try{return r.accessSync(e,r.constants.F_OK),!0}catch{return!1}}getCachedEvents(){let e=this.app.storagePath(`framework/events.json`);if(!r.existsSync(e))return new Map;try{let t=JSON.parse(r.readFileSync(e,`utf-8`));return new Map(t)}catch{return new Map}}listens(){return this.listen}};exports.EventServiceProvider=i;