asljs-eventful 0.1.6 → 0.2.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2025 Alex Netkachov
+Copyright (c) 2025 Alexandrite Software Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -32,7 +32,7 @@ const obj =
   eventful(
     { },
     { trace:
-        (object, action, payload) => {
+        (action, payload) => {
           console.log(
             `Action: ${action}`,
             payload);
@@ -40,10 +40,10 @@ const obj =
 
 // Tracing actions include:
 // - 'new' on creation: payload { object }
-// - 'on' when subscribing: payload { event, listener }
-// - 'off' when unsubscribing: payload { event, listener }
-// - 'emit' for sync emit: payload { event, args, listeners }
-// - 'emitAsync' for async emit: payload { event, args, listeners }
+// - 'on' when subscribing: payload { object, event, listener }
+// - 'off' when unsubscribing: payload { object, event, listener }
+// - 'emit' for sync emit: payload { object, event, args, listeners }
+// - 'emitAsync' for async emit: payload { object, event, args, listeners }
 ```
 
 Custom error handler for listener errors:
@@ -53,10 +53,10 @@ const obj =
   eventful(
     { },
     { error:
-        (err, { object, event, listener }) => {
+        ({ error, object, event, listener }) => {
           console.error(
             `Error in listener for event "${event}"`,
-            err);
+            error);
         } });
 ```
 
@@ -69,22 +69,32 @@ const obj =
     { strict: true });
 ```
 
-Change the error handler or trace function globally:
+### Global Events
+
+`eventful` is also a global emitter. When you create an enhanced object via `eventful(target, options)`, its lifecycle and actions are traced via the per-instance `trace` hook and also emitted as global events on `eventful`.
 
 ```js
-eventful.options.trace =
-  (object, action, payload) =>
-    console.log(
-      `Action: ${action}`,
-      payload);
-
-eventful.options.error =
-  (err, { object, event, listener }) =>
-    console.error(
-      `Error in listener for event "${event}"`,
-      err);
+const offNew =
+  eventful.on(
+    'new',
+    ({ object }) => {
+      console.log('created', object);
+    });
+
+const offError =
+  eventful.on(
+    'error',
+    ({ error, object, event }) => {
+      console.error('listener error', event, error);
+    });
+
+// Later
+offNew();
+offError();
 ```
 
+Note: if a **global** `eventful.on('error', ...)` listener throws, `eventful` throws a `ListenerError` (an `Error` subclass with fields `{ error, object, event, listener }`) to avoid an infinite error loop.
+
 ## API
 
 ### eventful([target], [options])
@@ -94,12 +104,8 @@ a new empty object is created.
 
 - `target` (Object): The object to be enhanced with event capabilities.
 - `options` (Object): Configuration options.
-  - `error` (Function | null): Custom error handler for listener errors
-    `(err, { object, event, listener })`. Defaults to `null`. Only called when
-    provided.
-  - `trace` (Function | null): Custom trace hook `(object, action, payload)`
-    for `new`, `on`, `off`, `emit`, `emitAsync`. Defaults to `null`. Only
-    called when provided.
+  - `error` (Function | null): Optional error hook called with `{ error, object, event, listener }`.
+  - `trace` (Function | null): Optional trace hook called with `(action, payload)`.
   - `strict` (Boolean): If true, propagates listener errors; otherwise they
     are isolated. Defaults to false.
 
@@ -107,7 +113,7 @@ a new empty object is created.
 
 Registers a listener for the specified event.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 - `listener` (Function): The callback function to be invoked when the event is
   emitted.
 
@@ -118,7 +124,7 @@ Returns a function to remove the listener.
 Registers a one-time listener for the specified event. The listener is removed
 after its first invocation.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 - `listener` (Function): The callback function to be invoked when the event is
   emitted.
 
@@ -139,7 +145,7 @@ obj.emit('tick', 2); // no-op; already unsubscribed
 
 Removes a listener for the specified event.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 - `listener` (Function): The callback function to be removed.
 
 ### emit(event, ...args)
@@ -147,7 +153,7 @@ Removes a listener for the specified event.
 Emits the specified event, invoking all registered listeners with the provided
 arguments.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 - `...args` (Any): Arguments to pass to the listeners.
 
 ### emitAsync(event, ...args)
@@ -156,7 +162,7 @@ Emits the specified event asynchronously, running listeners in parallel.
 In non-strict mode, all listeners run and rejections are isolated; in strict
 mode, the first rejection causes the returned promise to reject.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 - `...args` (Any): Arguments to pass to the listeners.
 
 Returns a Promise that resolves when all listeners have been invoked.
@@ -165,7 +171,7 @@ Returns a Promise that resolves when all listeners have been invoked.
 
 Checks if there are any listeners registered for the specified event.
 
-- `event` (String): The event name.
+- `event` (String | Symbol): The event name.
 
 Returns `true` if there are listeners, otherwise `false`.
 

package/dist/eventful.d.ts

@@ -0,0 +1,2 @@
+import type { EventfulFn } from './types.js';
+export declare const eventful: EventfulFn;

package/dist/eventful.js

@@ -0,0 +1,148 @@
+import { ListenerError } from './types.js';
+import { eventTypeGuard, functionTypeGuard, isFunction, isObject, } from './guards.js';
+const eventfulImpl = (object = Object.create(null), options = {}) => {
+    if (!isObject(object)
+        && !isFunction(object)) {
+        throw new TypeError('Expect an object or a function.');
+    }
+    for (const method of ['on', 'once', 'off', 'emit', 'emitAsync', 'has']) {
+        if (object[method] !== undefined) {
+            throw new Error(`Method "${method}" already exists.`);
+        }
+    }
+    const { strict = false, trace = null, error = null } = options;
+    const traceHook = typeof trace === 'function'
+        ? trace
+        : null;
+    const errorHook = typeof error === 'function'
+        ? error
+        : null;
+    const enhanced = object !== eventful;
+    const traceFn = (action, payload) => {
+        traceHook?.(action, payload);
+        if (enhanced) {
+            eventful.emit(action, payload);
+        }
+    };
+    traceFn('new', { object });
+    const emptySet = new Set();
+    const map = new Map();
+    const properties = { enumerable: false,
+        configurable: true,
+        writable: true };
+    Object.defineProperties(object, { on: Object.assign({ value: on }, properties),
+        once: Object.assign({ value: once }, properties),
+        off: Object.assign({ value: off }, properties),
+        emit: Object.assign({ value: emit }, properties),
+        emitAsync: Object.assign({ value: emitAsync }, properties),
+        has: Object.assign({ value: has }, properties) });
+    return object;
+    function add(event, listener) {
+        let listeners = map.get(event);
+        if (!listeners) {
+            map.set(event, listeners = new Set());
+        }
+        listeners.add(listener);
+    }
+    function remove(event, listener) {
+        const listeners = map.get(event);
+        if (!listeners)
+            return false;
+        const deleted = listeners.delete(listener);
+        if (listeners.size === 0)
+            map.delete(event);
+        return deleted;
+    }
+    function reportListenerError(event, listener, err) {
+        const errorArgs = { error: err,
+            object: object,
+            event,
+            listener };
+        errorHook?.(errorArgs);
+        if (object === eventful
+            && event === 'error') {
+            throw new ListenerError('Error in a global error listener.', err, object, event, listener);
+        }
+        eventful.emit('error', errorArgs);
+    }
+    function on(event, listener) {
+        eventTypeGuard(event);
+        functionTypeGuard(listener);
+        traceFn('on', { object,
+            event,
+            listener });
+        add(event, listener);
+        let active = true;
+        return () => active
+            ? ((active = false), remove(event, listener))
+            : false;
+    }
+    function once(event, listener) {
+        eventTypeGuard(event);
+        functionTypeGuard(listener);
+        const off = on(event, (...args) => {
+            off();
+            listener(...args);
+        });
+        return off;
+    }
+    function off(event, listener) {
+        eventTypeGuard(event);
+        functionTypeGuard(listener);
+        traceFn('off', { object,
+            event,
+            listener });
+        return remove(event, listener);
+    }
+    function has(event) {
+        eventTypeGuard(event);
+        return (map.get(event)?.size ?? 0) > 0;
+    }
+    function emit(event, ...args) {
+        eventTypeGuard(event);
+        const listeners = map.get(event)
+            || emptySet;
+        traceFn('emit', { object,
+            listeners: [...listeners],
+            event,
+            args });
+        if (listeners.size === 0)
+            return;
+        for (const listener of listeners) {
+            try {
+                listener(...args);
+            }
+            catch (err) {
+                reportListenerError(event, listener, err);
+                if (strict)
+                    throw err;
+            }
+        }
+    }
+    async function emitAsync(event, ...args) {
+        eventTypeGuard(event);
+        const listeners = map.get(event)
+            || emptySet;
+        traceFn('emitAsync', { object,
+            listeners: [...listeners],
+            event,
+            args });
+        if (listeners.size === 0)
+            return;
+        const calls = [...listeners].map(async (listener) => {
+            try {
+                await listener(...args);
+            }
+            catch (err) {
+                reportListenerError(event, listener, err);
+                if (strict)
+                    throw err;
+            }
+        });
+        await (strict
+            ? Promise.all(calls)
+            : Promise.allSettled(calls));
+    }
+};
+export const eventful = eventfulImpl;
+eventful(eventful);

package/dist/guards.d.ts

@@ -0,0 +1,5 @@
+import type { EventName } from './types.js';
+export declare function eventTypeGuard(value: any): asserts value is EventName;
+export declare function isFunction(value: any): value is Function;
+export declare function isObject(value: any): value is object;
+export declare function functionTypeGuard(value: any): asserts value is Function;

package/dist/guards.js

@@ -0,0 +1,18 @@
+export function eventTypeGuard(value) {
+    if (typeof value !== 'string'
+        && typeof value !== 'symbol') {
+        throw new TypeError('Expect event to be a string or symbol.');
+    }
+}
+export function isFunction(value) {
+    return typeof value === 'function';
+}
+export function isObject(value) {
+    return typeof value === 'object'
+        && value !== null;
+}
+export function functionTypeGuard(value) {
+    if (!isFunction(value)) {
+        throw new TypeError('Expect a function.');
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,97 @@
+export type EventName = string | symbol;
+export type EventMap = Record<EventName, any[]>;
+export type Listener<Args extends any[] = any[]> = (...args: Args) => any;
+export interface ListenerErrorArgs {
+    error: any;
+    object: object | Function;
+    event: EventName;
+    listener: Function;
+}
+export declare class ListenerError extends Error implements ListenerErrorArgs {
+    error: any;
+    object: object | Function;
+    event: EventName;
+    listener: Function;
+    constructor(message: string, error: any, object: object | Function, event: EventName, listener: Function);
+}
+type TraceAction = 'new' | 'on' | 'off' | 'emit' | 'emitAsync';
+type TracePayloadByAction = {
+    new: {
+        object: object | Function;
+    };
+    on: {
+        object: object | Function;
+        event: EventName;
+        listener: Function;
+    };
+    off: {
+        object: object | Function;
+        event: EventName;
+        listener: Function;
+    };
+    emit: {
+        object: object | Function;
+        listeners: Function[];
+        event: EventName;
+        args: any[];
+    };
+    emitAsync: {
+        object: object | Function;
+        listeners: Function[];
+        event: EventName;
+        args: any[];
+    };
+};
+export type TraceFn = <A extends TraceAction>(action: A, args: TracePayloadByAction[A]) => void;
+export type EventfulFn = EventfulFactory & Eventful;
+export interface EventfulFactory {
+    <T extends object | Function | undefined, E extends EventMap = EventMap>(object?: T, options?: EventfulOptions): (T extends undefined ? {} : T) & Eventful<E>;
+}
+export interface EventfulOptions {
+    /**
+     * If true, exceptions from listeners are propagated (fail fast).
+     * When false, errors are isolated (ignored) after calling `error` hook.
+     */
+    strict?: boolean;
+    /**
+     * Optional tracing hook. Receives action name and a safe payload.
+     * Actions include: 'new', 'on', 'off', 'emit', 'emitAsync'.
+     * Use to integrate with your logger without exposing internals.
+     */
+    trace?: TraceFn | null;
+    /**
+     * Optional error hook. Receives structured context of listener failures
+     * (error, object, event, listener). Called for sync and async errors.
+     */
+    error?: ((error: ListenerErrorArgs) => void) | null;
+}
+export interface Eventful<E extends EventMap = EventMap> {
+    /**
+     * Subscribe to an event. Returns an unsubscribe function.
+     */
+    on(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): () => boolean;
+    /**
+     * Subscribe once to an event. Returns an unsubscribe function
+     * (called automatically).
+     */
+    once(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): () => boolean;
+    /**
+     * Unsubscribe a previously registered listener. Returns true if removed.
+     */
+    off(event: keyof E & EventName, listener: Listener<E[keyof E & EventName]>): boolean;
+    /**
+     * Emit an event synchronously. All listeners run in order.
+     * Errors are isolated (ignored) unless `strict` is true.
+     */
+    emit(event: keyof E & EventName, ...args: E[keyof E & EventName]): void;
+    /**
+     * Emit an event and wait for all listeners (run in parallel).
+     * Errors are isolated (ignored) unless `strict` is true.
+     */
+    emitAsync(event: keyof E & EventName, ...args: E[keyof E & EventName]): Promise<void>;
+    /**
+     * Returns true if there is at least one listener for the event.
+     */
+    has(event: keyof E & EventName): boolean;
+}
+export {};

package/dist/types.js

@@ -0,0 +1,10 @@
+export class ListenerError extends Error {
+    constructor(message, error, object, event, listener) {
+        super(message);
+        this.name = 'ListenerError';
+        this.error = error;
+        this.object = object;
+        this.event = event;
+        this.listener = listener;
+    }
+}

package/eventful.d.ts

@@ -1,105 +1,14 @@
-
-export type Listener<Args extends any[] = any[]> =
-  (...args: Args) => any;
-
-export type EventMap =
-  Record<string | symbol, any[]>;
-
-export interface Eventful<E extends EventMap =
-  Record<string | symbol, any[]>> {
-    /** Subscribe to an event. Returns an unsubscribe function. */
-    on<K extends keyof E>(
-      event: K,
-      listener: Listener<E[K]>
-    ): () => boolean;
-
-    /** Subscribe once to an event. Returns an unsubscribe function (called automatically). */
-    once<K extends keyof E>(
-      event: K,
-      listener: Listener<E[K]>
-    ): () => boolean;
-
-    /** Unsubscribe a previously registered listener. */
-    off<K extends keyof E>(
-      event: K,
-      listener: Listener<E[K]>
-    ): boolean;
-
-    /** Emit an event synchronously. */
-    emit<K extends keyof E>(
-      event: K,
-      ...args: E[K]
-    ): void;
-
-    /** Emit an event and wait for all listeners (run in parallel, errors isolated unless strict). */
-    emitAsync<K extends keyof E>(
-      event: K,
-      ...args: E[K]
-    ): Promise<void>;
-
-    /** Returns true if there is at least one listener for the event. */
-    has<K extends keyof E>(
-      event: K
-    ): boolean;
-  }
-
-
-export interface ErrorContext {
-  object: object | Function;
-  event: string | symbol;
-  listener: Function;
-}
-
-type TracePayload =
-  | {
-      event: string | symbol;
-      args: any[];
-      listeners?: Function[];
-    }
-  | {
-      object: object | Function;
-    };
-
-export interface EventfulOptions {
-  /** If true, exceptions from listeners are propagated. Otherwise they are swallowed after calling `error`. */
-  strict?: boolean;
-
-  /** Optional tracing hook; defaults to `eventful.trace`. */
-  trace?: ((
-    object: object | Function,
-    action: string,
-    payload?: TracePayload
-  ) => void) | null;
-
-  /** Optional error hook; defaults to `eventful.error`. */
-  error?: ((
-    err: unknown,
-    context: ErrorContext
-  ) => void) | null;
-}
-
-export interface EventfulFactory {
-  <T extends object | Function | undefined,
-   E extends EventMap = Record<string | symbol, any[]>>(
-    object?: T,
-    options?: EventfulOptions
-  ): (T extends undefined ? {} : T) & Eventful<E>;
-
-  /** Global hooks you can override. */
-  options: {
-    /** Default tracer. Replace to integrate with your logger. */
-    trace: (
-      object: object | Function,
-      action: string,
-      payload?: TracePayload
-    ) => void | null;
-
-    /** Default error handler. Replace to integrate with your logger. */
-    error: (
-      err: unknown,
-      context: ErrorContext
-    ) => void | null;
-  };
-}
-
-export const eventful: EventfulFactory;
+export {
+  eventful
+} from './dist/eventful.js';
+
+export type {
+  EventName,
+  EventMap,
+  Eventful,
+  EventfulFactory,
+  EventfulOptions,
+  Listener,
+  ListenerError,
+  TraceFn
+} from './dist/types.js';

package/eventful.js

@@ -1,407 +1,3 @@
-/**
- * @typedef {Object} ErrorContext
- * @property {Object|Function} object The object emitting the event.
- * @property {string|symbol} event The event name.
- * @property {Function} listener The listener function that caused the error.
- */
-
-/**
- * @typedef {Object} EventfulOptions
- * @property {boolean} [strict] If true, exceptions from listeners are propagated.
- * @property {(object: Object|Function, action: string, payload: any) => void} [trace] Optional tracing hook.
- * @property {(err: any, context: ErrorContext) => void} [error] Optional error hook.
- */
-
-/**
- * A mixin that adds event emitter capabilities to an object.
- *
- * The method returns the original object enhanced with the event
- * subscribing and emitting methods.
- * 
- * If no object is provided, a new empty object is created and enhanced.
- * 
- * The options can configure the behavior of the event emitter.
- * 
- * @param {Object|Function} object The object to enhance.
- * @param {EventfulOptions} options The options to configure the event emitter.
- * @returns {Object|Function} The enhanced object.
- * 
- * @throws {TypeError} If the first argument is not an object or function.
- */
-const eventful =
-  (object = Object.create(null),
-   options = { }) =>
-  {
-    if ('object' !== typeof object
-        && 'function' !== typeof object)
-    {
-      throw new TypeError(
-        'Expect an object or a function.');
-    }
-
-    const emptySet =
-      new Set();
-  
-    const { strict = false,
-            trace = null,
-            error = null } =
-      options;
-
-    const globalOptions =
-      eventful.options;
-
-    const traceFn =
-      trace
-      || globalOptions.trace;
-
-    if (isFunction(traceFn)) {
-      traceFn(
-        object,
-        'new');
-    }
-
-    for (const method of
-        [ 'on',
-          'once',
-          'off',
-          'emit',
-          'emitAsync',
-          'has' ])
-    {
-      if (method in object) {
-        throw new Error(
-          `Method "${method}" already exists.`);
-      }
-    }
-
-    /** @type {Map<string|symbol, Set<Function>>} */
-    const map =
-      new Map();
-  
-    const add =
-      (event, listener) => {
-        eventTypeGuard(event);
-        functionTypeGuard(listener);
-
-        let listeners =
-          map.get(event);
-  
-        if (!listeners) {
-          listeners = new Set();
-          map.set(event, listeners);
-        }
-  
-        listeners.add(listener);
-      };
-  
-    const remove =
-      (event, listener) => {
-        eventTypeGuard(event);
-        functionTypeGuard(listener);
-
-        const listeners =
-          map.get(event);
-  
-        if (!listeners)
-          return false;
-  
-        const deleted =
-          listeners.delete(listener);
-  
-        if (listeners.size === 0)
-          map.delete(event);
-  
-        return deleted;
-      };
-
-    const getListeners =
-      event => {
-        eventTypeGuard(event);
-
-        return map.get(event)
-               || emptySet;
-      };
-  
-    /**
-     * Subscribe to an event.
-     *
-     * @type {(event: string|symbol, listener: Function) => () => boolean}
-     */
-    const on =
-      (event, listener) => {
-        eventTypeGuard(event);
-        functionTypeGuard(listener);
-  
-        const traceFn =
-          trace
-          || globalOptions.trace;
-
-        if (isFunction(traceFn)) {
-          traceFn(
-            object,
-            'on',
-            { event,
-              listener });
-        }
-  
-        add(
-          event,
-          listener);
-  
-        let active = true;
-  
-        return () => {
-          if (!active)
-            return false;
-  
-          active = false;
-  
-          return remove(
-            event,
-            listener);
-        };
-      };
-  
-    /**
-     * Subscribe to an event for a single occurrence.
-     *
-     * @type {(event: string|symbol, listener: Function) => () => boolean}
-     */
-    const once =
-      (event, listener) => {
-        eventTypeGuard(event);
-        functionTypeGuard(listener);
-  
-        const off =
-          on(
-            event,
-            (...args) => {
-              off();
-              listener(...args);
-            });
-  
-        return off;
-      };
-  
-    
-    /** @type {(event: string|symbol) => boolean} */
-    const has =
-      event => {
-        eventTypeGuard(event);
-
-        return map.get(event)?.size > 0
-               || false;
-      };
-  
-    /**
-     * Emit an event synchronously.
-     * All listeners run in order.
-     * Errors are isolated (ignored) unless `strict` is true.
-     *
-     * @param {string|symbol} event
-     * @param {...any} args
-     */
-    const emit =
-      (event, ...args) => {
-        eventTypeGuard(event);
-
-        const listeners =
-          getListeners(event);
-
-        const traceFn =
-          trace
-          || globalOptions.trace;
-
-        if (isFunction(traceFn)) {
-          traceFn(
-            object,
-            'emit',
-            { listeners: [...listeners],
-              event,
-              args });
-        }
-
-        if (listeners.size === 0)
-          return;
-          
-        for (const listener of listeners) {
-          try {
-            listener(...args);
-          } catch (err) {
-            const errorFn =
-              error
-              || globalOptions.error;
-
-            if (isFunction(errorFn)) {
-              const context =
-                { object,
-                  event,
-                  listener };
-
-              errorFn(
-                err,
-                context);
-            }
-
-            if (strict)
-              throw err;
-          }
-        }
-      };
-    
-    /**
-     * Emit an event and wait for all listeners (run in parallel).
-     * Errors are isolated (ignored) so all listeners run.
-     *
-     * @param {string|symbol} event
-     * @param {...any} args
-     * @returns {Promise<void>}
-     */
-    const emitAsync =
-      async (event, ...args) => {
-        eventTypeGuard(event);
-
-        const listeners =
-          getListeners(event);
-
-        const traceFn =
-          trace
-          || globalOptions.trace;
-
-        if (isFunction(traceFn)) {
-          traceFn(
-            object,
-            'emitAsync',
-            { listeners: [...listeners],
-              event,
-              args });
-        }
-
-        if (listeners.size === 0)
-          return;
-  
-        const calls =
-          Array.from(listeners)
-            .map(listener =>
-              new Promise(
-                (resolve, reject) => {
-                  try {
-                    Promise.resolve(
-                        listener(...args))
-                      .then(
-                        resolve,
-                        err => {
-                          const errorFn =
-                            error
-                            || globalOptions.error;
-                          
-                          if (isFunction(errorFn)) {
-                            const context =
-                              { object,
-                                event,
-                                listener };
-  
-                            errorFn(
-                              err,
-                              context);
-                          }
-  
-                          reject(err);
-                        });
-                  } catch (err) {
-                    const errorFn =
-                      error
-                      || globalOptions.error;
-                    
-                    if (isFunction(errorFn)) {
-                      const context =
-                        { object,
-                          event,
-                          listener };
-
-                      errorFn(
-                        err,
-                        context);
-                    }
-
-                    reject(err);
-                  }
-                }));
-
-        if (strict)
-          await Promise.all(calls);
-        else
-          await Promise.allSettled(calls);
-      };
-  
-    /**
-     * Unsubscribe from an event.
-     *
-     * @param {string} event The event name.
-     * @param {Function} listener The handling function.
-     * @returns {boolean} True if unsubscribed, false if not found.
-     */
-    const off =
-      (event, listener) => {
-        eventTypeGuard(event);
-        functionTypeGuard(listener);
-
-        const traceFn =
-          trace
-          || globalOptions.trace;
-
-        if (isFunction(traceFn)) {
-          traceFn(
-            object,
-            'off',
-            { event,
-              listener });
-        }
-  
-        return remove(
-          event,
-          listener);
-      };
-  
-    const attributes =
-     { enumerable: false,
-       configurable: true,
-       writable: true };
-  
-    Object.defineProperties(
-      object,
-      { on: { value: on, ...attributes },
-        once: { value: once, ...attributes },
-        off: { value: off, ...attributes },
-        emit: { value: emit, ...attributes },
-        emitAsync: { value: emitAsync, ...attributes },
-        has: { value: has, ...attributes } });
-  
-    return object;
-  };
-
-eventful.options =
-  { trace: null,
-    error: null };
-
-function eventTypeGuard(value) {
-  if ('string' !== typeof value
-      && 'symbol' !== typeof value)
-  {
-    throw new TypeError(
-      'Expect event to be a string or symbol.');
-  }
-}
-
-function isFunction(value) {
-  return 'function' === typeof value;
-}
-
-function functionTypeGuard(value) {
-  if (!isFunction(value)) {
-    throw new TypeError(
-      'Expect a function.');
-  }
-}
-
-export { eventful };
+export {
+  eventful
+} from './dist/eventful.js';

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "asljs-eventful",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Lightweight event helper adding on/off/emit to any object.",
+  "files": [
+    "dist/**",
+    "eventful.js",
+    "eventful.d.ts",
+    "README.md",
+    "LICENSE.md"
+  ],
   "keywords": [
     "events",
     "javascript",
@@ -20,12 +27,23 @@
   "type": "module",
   "main": "eventful.js",
   "types": "eventful.d.ts",
+  "exports": {
+    ".": {
+      "types": "./eventful.d.ts",
+      "default": "./eventful.js"
+    }
+  },
   "directories": {
     "doc": "docs"
   },
   "scripts": {
-    "test": "node --test",
-    "test:watch": "node --watch --test",
-    "coverage": "NODE_V8_COVERAGE=.coverage node --test && node -e \"console.log('Coverage in .coverage (use c8/istanbul if you want reports)')\""
+    "build": "tsc -p .",
+    "build:tests": "tsc -p tsconfig.tests.json",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepack": "npm run build",
+    "test": "npm run build && npm run build:tests && node --test .tests/*.test.js",
+    "test:watch": "npm run build && npm run build:tests && node --watch --test .tests/*.test.js",
+    "coverage": "npm run build && npm run build:tests && NODE_V8_COVERAGE=.coverage node --test .tests/*.test.js && node -e \"console.log('Coverage in .coverage (use c8/istanbul if you want reports)')\""
   }
 }

package/tests/eventful.test.js

@@ -1,305 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { eventful } from '../eventful.js';
-
-test(
-  'eventful does not create a new object',
-  () => {
-    const original = { };
-
-    const enhanced =
-      eventful(original);
-
-    assert.equal(
-      enhanced,
-      original);
-  });
-
-test(
-  'eventful extends a function',
-  () => {
-    const original =
-      () => { };
-
-    const enhanced =
-      eventful(original);
-
-    assert.equal(
-      enhanced,
-      original);
-  });
-
-test(
-  'trace is called on creation with action "new"',
-  () => {
-    const tracer =
-      createTracer();
-
-    const object =
-      eventful(
-        { },
-        { trace: tracer.trace });
-
-    const creation =
-      tracer.getFirstTraceByAction('new');
-      
-    assert.ok(creation);
-
-    assert.equal(
-      creation.object,
-      object);      
-  });
-
-test(
-  'eventful creates an empty event emitter object',
-  () => {
-    const obj =
-      eventful();
-
-    assert.ok(obj);
-    assert.equal(typeof obj.on, 'function');
-    assert.equal(typeof obj.off, 'function');
-    assert.equal(typeof obj.emit, 'function');
-    assert.equal(typeof obj.emitAsync, 'function');
-    assert.equal(typeof obj.has, 'function');
-  });
-
-test(
-  'eventful throws when an object has one of the event emitter methods',
-  () => {
-    for (const method of
-        [ 'on',
-          'once',
-          'off',
-          'emit',
-          'emitAsync',
-          'has'])
-    {
-      assert.throws(
-        () => eventful({ [method]: () => { } }));
-    }
-  });
-
-test(
-  'exceptions in listeners are suppressed by default',
-  async () => {
-    const obj =
-      eventful();
-
-    obj.on(
-      'test',
-      () => { throw new Error('test error'); });
-
-    await assert.doesNotReject(
-      () => obj.emitAsync('test'));
-  });
-
-test(
-  'strict mode propagates exceptions in listeners',
-  async () => {
-    const obj =
-      eventful(
-        { },
-        { error: () => { },
-          strict: true });
-
-    obj.on(
-      'test',
-      () => { throw new Error('test error'); });
-
-    await assert.rejects(
-      () => obj.emitAsync('test'));
-  });
-
-test(
-  'async listener rejection is suppressed by default',
-  async () => {
-    const obj =
-      eventful(
-        { },
-        { error: () => {} });
-
-    obj.on(
-      'test',
-      async () => { throw new Error('async fail'); });
-
-    await assert.doesNotReject(
-      () => obj.emitAsync('test'));
-  });
-
-test(
-  'non-strict runs other listeners even if one fails',
-  async () => {
-    const obj =
-      eventful(
-        { },
-        { error: () => {} });
-
-    let ran = 0;
-
-    obj.on(
-      'test',
-      () => { ran += 1; });
-
-    obj.on(
-      'test',
-      () => { throw new Error('boom'); });
-
-    obj.on(
-      'test',
-      () => { ran += 1; });
-
-    await assert.doesNotReject(
-      () => obj.emitAsync('test'));
-
-    assert.equal(ran, 2);
-  });  
-
-test(
-  'trace receives safe payload and action names',
-  async () => {
-    const tracer =
-      createTracer();
-
-    const obj =
-      eventful(
-        { },
-        { trace: tracer.trace });
-
-    const off = obj.on('e', () => {});
-    obj.emit('e', 1, 2);
-    await obj.emitAsync('e', 3, 4);
-    off();
-
-    // Expect actions at least 'on', 'emit', 'emitAsync'
-    assert.ok(tracer.getFirstTraceByAction('on'));
-    assert.ok(tracer.getFirstTraceByAction('emit'));
-    assert.ok(tracer.getFirstTraceByAction('emitAsync'));
-
-    const emitTrace =
-      tracer.getFirstTraceByAction('emit');
-
-    assert.ok(Array.isArray(emitTrace.payload.listeners));
-    assert.equal(emitTrace.payload.event, 'e');
-    assert.deepEqual(emitTrace.payload.args, [1, 2]);
-
-    const emitAsyncTrace =
-      tracer.getFirstTraceByAction('emitAsync');
-
-    assert.ok(Array.isArray(emitAsyncTrace.payload.listeners));
-    assert.equal(emitAsyncTrace.payload.event, 'e');
-    assert.deepEqual(emitAsyncTrace.payload.args, [3, 4]);
-  });
-
-test(
-  'error hook runs for async rejection (non-strict)',
-  async () => {
-    let errors = 0;
-    const obj =
-      eventful(
-        { },
-        { error: () => { errors += 1; } });
-
-    obj.on('e', async () => { throw new Error('reject'); });
-
-    await assert.doesNotReject(() => obj.emitAsync('e'));
-    assert.equal(errors, 1);
-  });
-
-test(
-  'has reflects subscribe and unsubscribe',
-  () => {
-    const obj =
-      eventful();
-
-    assert.equal(
-      obj.has('x'),
-      false);
-
-    const off =
-      obj.on(
-        'x',
-        () => { });
-
-    assert.equal(
-      obj.has('x'),
-      true);
-
-    off();
-
-    assert.equal(
-      obj.has('x'),
-      false);
-  });
-
-test(
-  'strict mode propagates async rejections',
-  async () => {
-    const obj =
-      eventful(
-        { },
-        { error: () => { },
-          strict: true });
-
-    obj.on(
-      'e',
-      async () => { throw new Error('nope'); });
-
-    await assert.rejects(() => obj.emitAsync('e'));
-  });
-
-test(
-  'emit ignores errors when no error hook (non-strict)',
-  () => {
-    const obj =
-      eventful();
-
-    obj.on(
-      'x',
-      () => { throw new Error('boom'); });
-
-    assert.doesNotThrow(
-      () => obj.emit('x'));
-  });
-
-test(
-  'event must be string or symbol',
-  () => {
-    const obj =
-      eventful();
-
-    assert.throws(
-      () => obj.on(123, () => {}),
-      TypeError);
-
-    assert.throws(
-      () => obj.emit(123),
-      TypeError);
-
-    const s =
-      Symbol('e');
-
-    assert.doesNotThrow(
-      () => obj.on(s, () => {}));
-
-    assert.doesNotThrow(
-      () => obj.emit(s));
-  });
-
-function createTracer() {
-  const traces = [];
-
-  return {
-    trace:
-      (object, action, payload) =>
-        traces.push({ object, action, payload }),
-    getTraces:
-      () => traces,
-    getTracesByAction:
-      action =>
-        traces.filter(t => t.action === action),
-    getFirstTraceByAction:
-      action =>
-        traces.find(t => t.action === action)
-  };
-}