API

EventEmitter#on(events, callback, scope) & EventEmitter#emit(events, …args)

/**
 * Adds a listener for a given event
 *
 * @param {EventInput} events
 * @param {ListenerCallback | object} callback
 * @param {object} scope
 * @returns EventEmitter
 * @memberof EventEmitter
 */

EventEmitter.prototype.on(events: EventInput, callback?: ListenerCallback | object, scope?: object);

/**
 * Call all listeners within an event
 *
 * @param {(string | Array<any>)} events
 * @param {...any} args
 * @returns EventEmitter
 * @memberof EventEmitter
 */

EventEmitter.prototype.emit(events: string | Array<any>, ...args: any);


// Example:
import EventEmitter from "@okikio/emitter";
const emitter = new EventEmitter();

let test = false;
let obj = ASTRO_ESCAPED_LEFT_CURLY_BRACKET bool: false };
let counter = 0;
let on = emitter.on(
    "test",
    function (key, value) ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        test = [key, value];

        // `this` comes from `obj`, since it was set as the scope of this listener
        console.log(this.bool); //= false
    },
    obj // Binds the callback to the `obj` scope
)

// You can chain methods
.on(
    // You can listen for multiple events at the same time
    "test test1 test2", // You can also use arrays ["test", "test1", "test2"]
    function (key, value) ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        test = [value, key];
        counter++;
        console.log(this.bool); //= undefined
    }
    // You can also bind all event listener callbacks to the same scope, in this example I didn't
);

on.emit("test", 1, "true");
console.log(test); //= [1, "true"]

on.emit(
    "test test1 test2", // You can also use arrays ["test", "test1", "test2"]
    1, "true");
console.log(test); //= ["true", 1]
console.log(counter); //= 3

counter = 0;
let fn = function (i = 1) ASTRO_ESCAPED_LEFT_CURLY_BRACKET
    return function (key, value) ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        test = [key, value];
        counter += i;
        console.log(this.bool); //= false
    };
};

// You can also use an object to listen for events
emitter.on(
    ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        play1: fn(),
        play2: fn(2),
        play3: fn(4)
    },
    obj // Bind all callbacks to the `obj` scope
);

// You can emit multiple events back to back
on.emit("play1 play2 play3 play1", "true", 1)
    .emit(["play1", "play2", "play3"], 1, "true");
console.log(test); //= [1, "true"]
console.log(counter); //= 15

EventEmitter#off(events, callback, scope)

EventEmitter.prototype.off(events: EventInput, callback?: ListenerCallback | object, scope?: object);

/**
 * Removes a listener from a given event, or completely removes an event
 *
 * @param {EventInput} events
 * @param {ListenerCallback | object} [callback]
 * @param {object} [scope]
 * @returns EventEmitter
 * @memberof EventEmitter
 */

// Example:
import EventEmitter from "@okikio/emitter";
const emitter = new EventEmitter();

/*
    `EventEmitter.prototype.off(...)` literally does the opposite of what `EventEmitter.prototype.on(...)` does,
    `EventEmitter.prototype.off(...)` removes Events and Event Listeners
*/
let counter = 0, fn, scope = ASTRO_ESCAPED_LEFT_CURLY_BRACKET bool: false };
let on = emitter.on(
    // You can listen for multiple events at the same time
    "test test1 test2", // You can also use arrays ["test", "test1", "test2"]
    fn = function () ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        counter++;
    },
    scope
);

// To remove an entire Event, or multiple Events
emitter.off("test1 test2");

// To remove a specific listener you need the scope (if you didn't put anything as the scope when listening for an Event then you don't need a scope) and callback
emitter.off("test", fn, scope);

on.emit("test test1 test2"); // Nothing happens, there are no Events or listeners, so, it can't emit anything
console.log(counter); //= 0

EventEmitter#once(events, callback, scope)

/**
 * Adds a one time event listener for an event
 *
 * @param {EventInput} events
 * @param {ListenerCallback | object} callback
 * @param {object} scope
 * @returns EventEmitter
 * @memberof EventEmitter
 */

EventEmitter.prototype.once(events: EventInput, callback?: ListenerCallback | object, scope?: object);


// Example:
import EventEmitter from "@okikio/emitter";
const emitter = new EventEmitter();

/**
 * `EventEmitter#once(...)` supports everything `EventEmitter#on(...)` supports
 * except the event listeners can only be fired once
 * */
let test: boolean | any = false;
let obj = ASTRO_ESCAPED_LEFT_CURLY_BRACKET bool: false };
let counter = 0;
let on: EventEmitter = emitter.once(
    "test test1 test2",
    function (key, value) ASTRO_ESCAPED_LEFT_CURLY_BRACKET
        test = [key, value];
        counter++;

        // `this` comes from `obj`, since it was set as the scope of this listener
        console.log(this.bool); //= false
    },
    obj
);

on.emit("test test1 test2", 1, "true");
console.log(test); //= [1, "true"]
console.log(counter); //= 3

// Since event listeners registered using the `once` method can only be emitted once\
// The second `emit` actually does nothing
on.emit("test test1 test2", 1, "true");
console.log(test); //= [1, "true"]
console.log(counter); //= 3

// The "test" event has no listeners registered since, they have already been removed
console.log(on.get("test").size) //= 0

Complete API Documentation

You can also go through the full API documentation, for a more detailed documentation of the API.