@dafengzhen/event-bus 0.1.5 → 0.1.7

package/dist/types/event-bus.d.ts

@@ -0,0 +1,178 @@
+import type { AnyListener, EventMap, Listener, Middleware, PatternMiddleware, PatternOptions } from './types.ts';
+/**
+ * A strongly-typed EventBus supporting:
+ *
+ * - Exact event listeners (`on`, `once`)
+ * - Global listeners (`onAny`)
+ * - Pattern listeners (`onPattern`, `oncePattern`)
+ * - Global middleware & pattern middleware
+ *
+ * Pattern syntax (separator defaults to `:`):
+ * - `*`      → single-segment wildcard
+ * - `**`     → deep wildcard (matches 0..n segments)
+ * - `{name}` → named parameter segment
+ * - `?`      → single-character wildcard within a segment (regex-like)
+ *
+ * Error handling:
+ * - Listener errors are rethrown asynchronously via `queueMicrotask`,
+ *   so they don't break the current emit loop.
+ *
+ * Emit modes:
+ * - `emit()`     : fire-and-forget (async errors rethrown)
+ * - `emitAsync()`: await completion of middleware + listeners
+ *
+ * @example
+ * ```ts
+ * type Events = {
+ *   'user:login': { id: string };
+ *   'user:logout': void;
+ * };
+ *
+ * const bus = new EventBus<Events>();
+ *
+ * bus.on('user:login', (p) => console.log(p.id));
+ * bus.onPattern('user:{action}', (evt, payload, params) => {
+ *   console.log(evt, params?.action);
+ * });
+ *
+ * bus.emit('user:login', { id: '42' });
+ * ```
+ *
+ * @author dafengzhen
+ */
+export declare class EventBus<E extends EventMap> {
+    /** Listeners that receive all events */
+    private anyListeners;
+    /** Exact listeners mapped by event name */
+    private listenersByEvent;
+    /** Global middleware chain (runs on every emit) */
+    private middlewares;
+    /**
+     * Pattern-specific middleware chain.
+     * Only runs when there is at least one matched pattern listener for the emitted event.
+     */
+    private patternMiddlewares;
+    /** Compiled pattern listeners, sorted by priority (descending) */
+    private patternListeners;
+    /** Cache for compiled patterns (pattern + separator) */
+    private patternCache;
+    /**
+     * Clear listeners and middleware.
+     * - If `event` is omitted, clears everything (exact/any/pattern listeners + middleware + cache).
+     * - If `event` is provided, only clears exact listeners of that event.
+     */
+    clear(event?: keyof E): void;
+    /**
+     * Register an exact listener for a specific event.
+     * @returns Unsubscribe function
+     */
+    on<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
+    /**
+     * Remove an exact event listener (no-op if missing).
+     */
+    off<K extends keyof E>(event: K, listener: Listener<E[K]>): void;
+    /**
+     * Register an exact listener that runs only once.
+     * @returns Unsubscribe function (still works before the first run)
+     */
+    once<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
+    /**
+     * Register a listener that receives all events.
+     * @returns Unsubscribe function
+     */
+    onAny(listener: AnyListener<E>): () => void;
+    /**
+     * Remove a global (any) listener (no-op if missing).
+     */
+    offAny(listener: AnyListener<E>): void;
+    /**
+     * Register a global (any) listener that runs only once.
+     * @returns Unsubscribe function (still works before the first run)
+     */
+    onceAny(listener: AnyListener<E>): () => void;
+    /**
+     * Register a global middleware (runs on every emit).
+     *
+     * Middleware must call `next()` exactly once to continue.
+     * If it never calls `next()`, dispatch stops.
+     *
+     * @returns Unsubscribe function
+     */
+    use(mw: Middleware<E>): () => void;
+    /**
+     * Register a pattern-specific middleware.
+     *
+     * Only invoked when there is at least one matched pattern listener.
+     *
+     * Gate semantics:
+     * - If a pattern middleware does not call `next()`, dispatch stops (acts like a guard).
+     * - `next()` must be called exactly once.
+     *
+     * @returns Unsubscribe function
+     */
+    usePattern(mw: PatternMiddleware<E>): () => void;
+    /**
+     * Register a pattern listener.
+     *
+     * Supported syntax (separator defaults to `:`):
+     * - `*`      → single-segment wildcard
+     * - `**`     → deep wildcard (matches 0..n segments)
+     * - `{param}`→ named parameter segment
+     * - `?`      → single-character wildcard inside a segment
+     *
+     * Priority:
+     * - If `options.priority` is provided, it overrides auto-derived priority.
+     * - Higher priority runs earlier.
+     *
+     * @param pattern Pattern string
+     * @param handler Callback invoked when pattern matches
+     * @param options Pattern options
+     * @returns Unsubscribe function
+     */
+    onPattern(pattern: string, handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void, options?: PatternOptions): () => void;
+    /**
+     * Register a one-time pattern listener.
+     * @returns Unsubscribe function
+     */
+    oncePattern(pattern: string, handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void, options?: Omit<PatternOptions, 'once'>): () => void;
+    /**
+     * Count listeners matching the event.
+     *
+     * Includes:
+     * - Exact listeners for `event`
+     * - Global `onAny` listeners
+     * - Pattern listeners that match (only when `event` is a string)
+     */
+    listenerCount(event: keyof E): number;
+    /**
+     * Emit an event synchronously (fire-and-forget).
+     *
+     * - Execution is async internally, but this method does not await.
+     * - Listener errors are rethrown asynchronously.
+     */
+    emit<K extends keyof E>(event: K, ...args: E[K] extends void ? [] : [payload: E[K]]): void;
+    /**
+     * Emit an event asynchronously.
+     * Resolves when middleware + listeners have finished.
+     */
+    emitAsync<K extends keyof E>(event: K, ...args: E[K] extends void ? [] : [payload: E[K]]): Promise<void>;
+    private _emit;
+    private runMiddlewares;
+    private invokeUnifiedDispatch;
+    private matchPatternListeners;
+    private invokeExactAndAnyListeners;
+    private getListenerSet;
+    private insertPatternByPriority;
+    private removeFromArray;
+    private safeCall;
+    private rethrowAsync;
+    /**
+     * Compile a pattern into a matcher.
+     *
+     * Notes:
+     * - `**` as a segment means "match 0..n segments" (deep wildcard).
+     * - `*`  as a segment means "match exactly 1 segment".
+     * - If the whole pattern is exactly `"**"`, it matches any event (including empty params).
+     */
+    private compilePattern;
+}

package/dist/types/event-bus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -1,440 +1,2 @@
-/**
- * Event map definition.
- *
- * A mapping from **event name** to **payload type**.
- *
- * - **Key**: event name (string literal recommended)
- * - **Value**: payload type for that event
- *
- * Notes:
- * - Event names are typically namespaced strings, e.g. `user:login`, `order:created`.
- * - Payload can be `void` for events without payload.
- *
- * @example
- * ```ts
- * type MyEvents = {
- *   'user:login': { id: string };
- *   'user:logout': void;
- * };
- * ```
- */
-export type EventMap = Record<string, unknown>;
-/**
- * Listener type for a specific payload.
- *
- * If the payload is `void`, the listener receives **no arguments**.
- * Otherwise, it receives **exactly one argument**: the payload.
- *
- * This enables strict typing for both forms:
- *
- * @example
- * ```ts
- * on('ready', () => {});
- * on('data', (payload) => {
- *   console.log(payload);
- * });
- * ```
- */
-export type Listener<Payload> = Payload extends void ? () => void : (payload: Payload) => void;
-/**
- * Listener that receives **all emitted events**.
- *
- * It receives:
- * - `event`: the event name
- * - `payload`: the payload associated with that event
- *
- * Typical use cases:
- * - logging / debugging
- * - analytics / tracing
- * - building devtools
- *
- * @example
- * ```ts
- * const off = bus.onAny((event, payload) => {
- *   console.log('event=', event, 'payload=', payload);
- * });
- * off();
- * ```
- */
-export type AnyListener<E extends EventMap> = <K extends keyof E>(event: K, payload: E[K]) => void;
-/**
- * Pattern matching strategy used by a pattern listener.
- *
- * - `exact`    → exact segment match (no wildcards / params)
- * - `wildcard` → contains wildcards (e.g. `*`, `**`, `?`)
- * - `param`    → contains named params (e.g. `{id}`)
- *
- * Notes:
- * - These are informational categories; the actual matching is implemented by the EventBus.
- */
-export type PatternKind = 'exact' | 'wildcard' | 'param';
-/**
- * Context object passed through the emit lifecycle.
- *
- * This context is shared across:
- * - global middleware
- * - pattern middleware
- * - dispatch logic
- *
- * It allows middleware to:
- * - observe the event and payload
- * - attach metadata (`meta`)
- * - stop propagation (`block()`)
- */
-export type EmitContext<E extends EventMap, K extends keyof E> = {
-    /**
-     * Whether propagation has been blocked.
-     *
-     * Once `true`, dispatch stops and no further middleware/listeners should run.
-     */
-    readonly blocked: boolean;
-    /**
-     * Current emitted event name.
-     */
-    readonly event: K;
-    /**
-     * Payload associated with the event.
-     *
-     * If the event's payload type is `void`, this value is typically `undefined`
-     * (depending on the emitter implementation).
-     */
-    readonly payload: E[K];
-    /**
-     * Information about matched pattern listeners for this emit cycle.
-     *
-     * - Ordered by priority (highest first).
-     * - Empty if no pattern listeners matched (or pattern matching not applicable).
-     *
-     * Useful for middleware that wants to inspect or audit matches.
-     */
-    readonly matched: readonly PatternListenerInfo<E>[];
-    /**
-     * Free-form metadata container shared across middleware.
-     *
-     * Use this to pass state between middleware, e.g.:
-     * - correlation IDs
-     * - timing info
-     * - auth decisions
-     *
-     * Note: Consumers should avoid putting large objects here in hot paths.
-     */
-    readonly meta: Record<string, unknown>;
-    /**
-     * Stop further propagation of this event.
-     *
-     * Once called:
-     * - remaining middleware is skipped
-     * - remaining listeners are not executed
-     */
-    block(): void;
-};
-/**
- * Middleware executed for **every emit call**.
- *
- * Middleware can:
- * - inspect event/payload/matches
- * - read/write `ctx.meta`
- * - block propagation via `ctx.block()`
- * - perform async work
- *
- * Chain semantics:
- * - Middlewares are executed sequentially in registration order.
- * - `next()` must be called exactly once to continue the chain (depending on implementation).
- */
-export type Middleware<E extends EventMap> = <K extends keyof E>(ctx: EmitContext<E, K>, next: () => Promise<void>) => Promise<void> | void;
-/**
- * Middleware executed **only when pattern listeners are involved**.
- *
- * Typical uses:
- * - logging pattern matches & params
- * - permission checks / gating
- * - validating extracted params
- *
- * Chain semantics depend on the EventBus implementation.
- * In your EventBus, pattern middleware acts as a guard:
- * - if it does not call `next()`, dispatch stops
- * - `next()` must not be called more than once
- */
-export type PatternMiddleware<E extends EventMap> = (ctx: EmitContext<E, keyof E>, next: () => Promise<void>) => Promise<void> | void;
-/**
- * Public information of a matched pattern listener.
- *
- * Exposed to middleware and user-land code through `ctx.matched`.
- */
-export interface PatternListenerInfo<E extends EventMap> {
-    /**
-     * Original pattern string.
-     *
-     * @example
-     * ```ts
-     * 'user:{id}'
-     * 'order:*'
-     * '**'
-     * ```
-     */
-    readonly pattern: string;
-    /**
-     * Matching strategy classification.
-     */
-    readonly kind: PatternKind;
-    /**
-     * Listener priority. Higher values run earlier.
-     */
-    readonly priority: number;
-    /**
-     * Whether this listener was registered with `once`.
-     */
-    readonly once?: boolean;
-    /**
-     * Extracted params from the event name.
-     *
-     * Example (separator `:`):
-     * - pattern: `user:{id}`
-     * - event:   `user:42`
-     * - params:  `{ id: '42' }`
-     */
-    readonly params: Readonly<Record<string, string>>;
-    /**
-     * The actual handler function.
-     *
-     * Note:
-     * - Kept here mainly for introspection/debugging.
-     * - Middleware should generally not call handlers directly.
-     */
-    readonly handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void;
-}
-/**
- * Internal compiled representation of a pattern listener.
- *
- * Not exposed publicly.
- * Contains precompiled matching logic for performance.
- */
-export interface CompiledPatternListener<E extends EventMap> {
-    /**
-     * Original pattern string (uncompiled).
-     */
-    pattern: string;
-    /**
-     * Matching strategy classification.
-     */
-    kind: PatternKind;
-    /**
-     * Listener priority. Higher values run earlier.
-     */
-    priority: number;
-    /**
-     * Whether the listener should auto-remove after first run.
-     */
-    once?: boolean;
-    /**
-     * Match function produced by the compiler.
-     *
-     * @param event - Emitted event name
-     * @returns
-     * - `null` if no match
-     * - params record if matched (possibly empty)
-     */
-    match(event: string): null | Record<string, string>;
-    /**
-     * Listener handler.
-     *
-     * @param event  - Emitted event name
-     * @param payload - Payload associated with event
-     * @param params - Extracted params from pattern (if any)
-     */
-    handler(event: keyof E, payload: E[keyof E], params?: Record<string, string>): void;
-}
-/**
- * Options for registering a pattern listener.
- */
-export type PatternOptions = {
-    /**
-     * Invoke the listener only once.
-     *
-     * After the first successful match, it is automatically removed.
-     */
-    once?: boolean;
-    /**
-     * Listener priority.
-     *
-     * Higher values run earlier.
-     * If omitted, EventBus will derive a priority from pattern specificity.
-     */
-    priority?: number;
-    /**
-     * Segment separator used when splitting patterns and events.
-     *
-     * IMPORTANT:
-     * - This default should match your EventBus implementation.
-     * - In the current EventBus code you posted, the default is `':'`.
-     */
-    separator?: string;
-};
-/**
- * Internal compiled segment representation produced by the pattern compiler.
- *
- * - `exact`        → exact segment match
- * - `wildcard`     → `*` matches exactly one segment
- * - `deepWildcard` → `**` matches 0..n segments (backtracking)
- * - `param`        → `{key}` captures a segment into params
- * - `regex`        → per-segment regex (used for `?` patterns)
- */
-export type CompiledSeg = {
-    type: 'exact';
-    value: string;
-} | {
-    type: 'wildcard';
-} | {
-    type: 'deepWildcard';
-} | {
-    type: 'param';
-    key: string;
-} | {
-    type: 'regex';
-    re: RegExp;
-};
-/**
- * A strongly-typed EventBus supporting:
- *
- * - Exact event listeners (`on`, `once`)
- * - Global listeners (`onAny`)
- * - Pattern listeners (`onPattern`, `oncePattern`)
- * - Global middleware & pattern middleware
- *
- * Pattern syntax (separator defaults to `:`):
- * - `*`      → single-segment wildcard
- * - `**`     → deep wildcard (matches 0..n segments)
- * - `{name}` → named parameter segment
- * - `?`      → single-character wildcard within a segment (regex-like)
- *
- * Error handling:
- * - Listener errors are rethrown asynchronously via `queueMicrotask`,
- *   so they don't break the current emit loop.
- *
- * Emit modes:
- * - `emit()`     : fire-and-forget (async errors rethrown)
- * - `emitAsync()`: await completion of middleware + listeners
- *
- * @example
- * ```ts
- * type Events = {
- *   'user:login': { id: string };
- *   'user:logout': void;
- * };
- *
- * const bus = new EventBus<Events>();
- *
- * bus.on('user:login', (p) => console.log(p.id));
- * bus.onPattern('user:{action}', (evt, payload, params) => {
- *   console.log(evt, params?.action);
- * });
- *
- * bus.emit('user:login', { id: '42' });
- * ```
- *
- * @author dafengzhen
- */
-export class EventBus<E extends EventMap> {
-    /**
-     * Clear listeners and middleware.
-     * - If `event` is omitted, clears everything (exact/any/pattern listeners + middleware + cache).
-     * - If `event` is provided, only clears exact listeners of that event.
-     */
-    clear(event?: keyof E): void;
-    /**
-     * Register an exact listener for a specific event.
-     * @returns Unsubscribe function
-     */
-    on<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
-    /**
-     * Remove an exact event listener (no-op if missing).
-     */
-    off<K extends keyof E>(event: K, listener: Listener<E[K]>): void;
-    /**
-     * Register an exact listener that runs only once.
-     * @returns Unsubscribe function (still works before the first run)
-     */
-    once<K extends keyof E>(event: K, listener: Listener<E[K]>): () => void;
-    /**
-     * Register a listener that receives all events.
-     * @returns Unsubscribe function
-     */
-    onAny(listener: AnyListener<E>): () => void;
-    /**
-     * Remove a global (any) listener (no-op if missing).
-     */
-    offAny(listener: AnyListener<E>): void;
-    /**
-     * Register a global (any) listener that runs only once.
-     * @returns Unsubscribe function (still works before the first run)
-     */
-    onceAny(listener: AnyListener<E>): () => void;
-    /**
-     * Register a global middleware (runs on every emit).
-     *
-     * Middleware must call `next()` exactly once to continue.
-     * If it never calls `next()`, dispatch stops.
-     *
-     * @returns Unsubscribe function
-     */
-    use(mw: Middleware<E>): () => void;
-    /**
-     * Register a pattern-specific middleware.
-     *
-     * Only invoked when there is at least one matched pattern listener.
-     *
-     * Gate semantics:
-     * - If a pattern middleware does not call `next()`, dispatch stops (acts like a guard).
-     * - `next()` must be called exactly once.
-     *
-     * @returns Unsubscribe function
-     */
-    usePattern(mw: PatternMiddleware<E>): () => void;
-    /**
-     * Register a pattern listener.
-     *
-     * Supported syntax (separator defaults to `:`):
-     * - `*`      → single-segment wildcard
-     * - `**`     → deep wildcard (matches 0..n segments)
-     * - `{param}`→ named parameter segment
-     * - `?`      → single-character wildcard inside a segment
-     *
-     * Priority:
-     * - If `options.priority` is provided, it overrides auto-derived priority.
-     * - Higher priority runs earlier.
-     *
-     * @param pattern Pattern string
-     * @param handler Callback invoked when pattern matches
-     * @param options Pattern options
-     * @returns Unsubscribe function
-     */
-    onPattern(pattern: string, handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void, options?: PatternOptions): () => void;
-    /**
-     * Register a one-time pattern listener.
-     * @returns Unsubscribe function
-     */
-    oncePattern(pattern: string, handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void, options?: Omit<PatternOptions, 'once'>): () => void;
-    /**
-     * Count listeners matching the event.
-     *
-     * Includes:
-     * - Exact listeners for `event`
-     * - Global `onAny` listeners
-     * - Pattern listeners that match (only when `event` is a string)
-     */
-    listenerCount(event: keyof E): number;
-    /**
-     * Emit an event synchronously (fire-and-forget).
-     *
-     * - Execution is async internally, but this method does not await.
-     * - Listener errors are rethrown asynchronously.
-     */
-    emit<K extends keyof E>(event: K, ...args: E[K] extends void ? [] : [payload: E[K]]): void;
-    /**
-     * Emit an event asynchronously.
-     * Resolves when middleware + listeners have finished.
-     */
-    emitAsync<K extends keyof E>(event: K, ...args: E[K] extends void ? [] : [payload: E[K]]): Promise<void>;
-}
-
-//# sourceMappingURL=index.d.ts.map
+export type * from './types.ts';
+export * from './event-bus.ts';

package/dist/types/types.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Event map definition.
+ *
+ * A mapping from **event name** to **payload type**.
+ *
+ * - **Key**: event name (string literal recommended)
+ * - **Value**: payload type for that event
+ *
+ * Notes:
+ * - Event names are typically namespaced strings, e.g. `user:login`, `order:created`.
+ * - Payload can be `void` for events without payload.
+ *
+ * @example
+ * ```ts
+ * type MyEvents = {
+ *   'user:login': { id: string };
+ *   'user:logout': void;
+ * };
+ * ```
+ */
+export type EventMap = Record<string, any>;
+/**
+ * Listener type for a specific payload.
+ *
+ * If the payload is `void`, the listener receives **no arguments**.
+ * Otherwise, it receives **exactly one argument**: the payload.
+ *
+ * This enables strict typing for both forms:
+ *
+ * @example
+ * ```ts
+ * on('ready', () => {});
+ * on('data', (payload) => {
+ *   console.log(payload);
+ * });
+ * ```
+ */
+export type Listener<Payload> = Payload extends void ? () => void : (payload: Payload) => void;
+/**
+ * Listener that receives **all emitted events**.
+ *
+ * It receives:
+ * - `event`: the event name
+ * - `payload`: the payload associated with that event
+ *
+ * Typical use cases:
+ * - logging / debugging
+ * - analytics / tracing
+ * - building devtools
+ *
+ * @example
+ * ```ts
+ * const off = bus.onAny((event, payload) => {
+ *   console.log('event=', event, 'payload=', payload);
+ * });
+ * off();
+ * ```
+ */
+export type AnyListener<E extends EventMap> = <K extends keyof E>(event: K, payload: E[K]) => void;
+/**
+ * Pattern matching strategy used by a pattern listener.
+ *
+ * - `exact`    → exact segment match (no wildcards / params)
+ * - `wildcard` → contains wildcards (e.g. `*`, `**`, `?`)
+ * - `param`    → contains named params (e.g. `{id}`)
+ *
+ * Notes:
+ * - These are informational categories; the actual matching is implemented by the EventBus.
+ */
+export type PatternKind = 'exact' | 'wildcard' | 'param';
+/**
+ * Context object passed through the emit lifecycle.
+ *
+ * This context is shared across:
+ * - global middleware
+ * - pattern middleware
+ * - dispatch logic
+ *
+ * It allows middleware to:
+ * - observe the event and payload
+ * - attach metadata (`meta`)
+ * - stop propagation (`block()`)
+ */
+export type EmitContext<E extends EventMap, K extends keyof E> = {
+    /**
+     * Whether propagation has been blocked.
+     *
+     * Once `true`, dispatch stops and no further middleware/listeners should run.
+     */
+    readonly blocked: boolean;
+    /**
+     * Current emitted event name.
+     */
+    readonly event: K;
+    /**
+     * Payload associated with the event.
+     *
+     * If the event's payload type is `void`, this value is typically `undefined`
+     * (depending on the emitter implementation).
+     */
+    readonly payload: E[K];
+    /**
+     * Information about matched pattern listeners for this emit cycle.
+     *
+     * - Ordered by priority (highest first).
+     * - Empty if no pattern listeners matched (or pattern matching not applicable).
+     *
+     * Useful for middleware that wants to inspect or audit matches.
+     */
+    readonly matched: readonly PatternListenerInfo<E>[];
+    /**
+     * Free-form metadata container shared across middleware.
+     *
+     * Use this to pass state between middleware, e.g.:
+     * - correlation IDs
+     * - timing info
+     * - auth decisions
+     *
+     * Note: Consumers should avoid putting large objects here in hot paths.
+     */
+    readonly meta: Record<string, unknown>;
+    /**
+     * Stop further propagation of this event.
+     *
+     * Once called:
+     * - remaining middleware is skipped
+     * - remaining listeners are not executed
+     */
+    block(): void;
+};
+/**
+ * Middleware executed for **every emit call**.
+ *
+ * Middleware can:
+ * - inspect event/payload/matches
+ * - read/write `ctx.meta`
+ * - block propagation via `ctx.block()`
+ * - perform async work
+ *
+ * Chain semantics:
+ * - Middlewares are executed sequentially in registration order.
+ * - `next()` must be called exactly once to continue the chain (depending on implementation).
+ */
+export type Middleware<E extends EventMap> = <K extends keyof E>(ctx: EmitContext<E, K>, next: () => Promise<void>) => Promise<void> | void;
+/**
+ * Middleware executed **only when pattern listeners are involved**.
+ *
+ * Typical uses:
+ * - logging pattern matches & params
+ * - permission checks / gating
+ * - validating extracted params
+ *
+ * Chain semantics depend on the EventBus implementation.
+ * In your EventBus, pattern middleware acts as a guard:
+ * - if it does not call `next()`, dispatch stops
+ * - `next()` must not be called more than once
+ */
+export type PatternMiddleware<E extends EventMap> = (ctx: EmitContext<E, keyof E>, next: () => Promise<void>) => Promise<void> | void;
+/**
+ * Public information of a matched pattern listener.
+ *
+ * Exposed to middleware and user-land code through `ctx.matched`.
+ */
+export interface PatternListenerInfo<E extends EventMap> {
+    /**
+     * Original pattern string.
+     *
+     * @example
+     * ```ts
+     * 'user:{id}'
+     * 'order:*'
+     * '**'
+     * ```
+     */
+    readonly pattern: string;
+    /**
+     * Matching strategy classification.
+     */
+    readonly kind: PatternKind;
+    /**
+     * Listener priority. Higher values run earlier.
+     */
+    readonly priority: number;
+    /**
+     * Whether this listener was registered with `once`.
+     */
+    readonly once?: boolean;
+    /**
+     * Extracted params from the event name.
+     *
+     * Example (separator `:`):
+     * - pattern: `user:{id}`
+     * - event:   `user:42`
+     * - params:  `{ id: '42' }`
+     */
+    readonly params: Readonly<Record<string, string>>;
+    /**
+     * The actual handler function.
+     *
+     * Note:
+     * - Kept here mainly for introspection/debugging.
+     * - Middleware should generally not call handlers directly.
+     */
+    readonly handler: (event: keyof E, payload: E[keyof E], params?: Record<string, string>) => void;
+}
+/**
+ * Internal compiled representation of a pattern listener.
+ *
+ * Not exposed publicly.
+ * Contains precompiled matching logic for performance.
+ */
+export interface CompiledPatternListener<E extends EventMap> {
+    /**
+     * Original pattern string (uncompiled).
+     */
+    pattern: string;
+    /**
+     * Matching strategy classification.
+     */
+    kind: PatternKind;
+    /**
+     * Listener priority. Higher values run earlier.
+     */
+    priority: number;
+    /**
+     * Whether the listener should auto-remove after first run.
+     */
+    once?: boolean;
+    /**
+     * Match function produced by the compiler.
+     *
+     * @param event - Emitted event name
+     * @returns
+     * - `null` if no match
+     * - params record if matched (possibly empty)
+     */
+    match(event: string): null | Record<string, string>;
+    /**
+     * Listener handler.
+     *
+     * @param event  - Emitted event name
+     * @param payload - Payload associated with event
+     * @param params - Extracted params from pattern (if any)
+     */
+    handler(event: keyof E, payload: E[keyof E], params?: Record<string, string>): void;
+}
+/**
+ * Options for registering a pattern listener.
+ */
+export type PatternOptions = {
+    /**
+     * Invoke the listener only once.
+     *
+     * After the first successful match, it is automatically removed.
+     */
+    once?: boolean;
+    /**
+     * Listener priority.
+     *
+     * Higher values run earlier.
+     * If omitted, EventBus will derive a priority from pattern specificity.
+     */
+    priority?: number;
+    /**
+     * Segment separator used when splitting patterns and events.
+     *
+     * IMPORTANT:
+     * - This default should match your EventBus implementation.
+     * - In the current EventBus code you posted, the default is `':'`.
+     */
+    separator?: string;
+};
+/**
+ * Internal compiled segment representation produced by the pattern compiler.
+ *
+ * - `exact`        → exact segment match
+ * - `wildcard`     → `*` matches exactly one segment
+ * - `deepWildcard` → `**` matches 0..n segments (backtracking)
+ * - `param`        → `{key}` captures a segment into params
+ * - `regex`        → per-segment regex (used for `?` patterns)
+ */
+export type CompiledSeg = {
+    type: 'exact';
+    value: string;
+} | {
+    type: 'wildcard';
+} | {
+    type: 'deepWildcard';
+} | {
+    type: 'param';
+    key: string;
+} | {
+    type: 'regex';
+    re: RegExp;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dafengzhen/event-bus",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A lightweight TypeScript event bus with strong typing, middleware pipeline, and pattern-based event listeners.",
   "keywords": [
     "event-bus",
@@ -23,21 +23,27 @@
     "type": "git",
     "url": "git+https://github.com/dafengzhen/event-bus.git"
   },
-  "source": "./src/index.ts",
   "files": [
     "dist"
   ],
   "type": "module",
+  "main": "./dist/cjs/modern/index.js",
+  "module": "./dist/esm/modern/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/esm/modern/index.js",
-      "require": "./dist/cjs/modern/index.js"
+      "require": "./dist/cjs/modern/index.js",
+      "default": "./dist/esm/modern/index.js"
     }
   },
   "scripts": {
-    "build": "parcel build",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:modern": "parcel build src/index.ts --target modern-esm --target modern-cjs",
+    "build:legacy": "parcel build src/index.ts --target legacy-esm --target legacy-cjs",
+    "build:dev": "parcel build src/index.ts --target modern-esm-dev --target modern-cjs-dev --target legacy-esm-dev --target legacy-cjs-dev",
+    "build": "npm run build:types && npm run build:modern && npm run build:legacy && npm run build:dev",
     "prepare": "husky install",
     "test": "jest",
     "watch": "parcel watch",

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"mappings":"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","sources":["src/src/types.ts","src/src/event-bus.ts","src/src/index.ts","src/index.ts"],"sourcesContent":[null,null,null,"export type * from './types.ts';\nexport * from './event-bus.ts';\n"],"names":[],"version":3,"file":"index.d.ts.map"}