@signaldb/core 1.7.2 → 1.8.1

package/dist/index10.cjs.js

@@ -0,0 +1,265 @@
+const require_sortItems = require("./index3.cjs.js");
+const require_project = require("./index5.cjs.js");
+const require_deepClone = require("./index6.cjs.js");
+const require_Observer = require("./index9.cjs.js");
+//#region src/Collection/Cursor.ts
+/**
+* Checks if the current scope is reactive, considering the provided reactivity adapter.
+* @param reactivity - The reactivity adapter or a boolean indicating whether reactivity is enabled.
+* @returns A boolean indicating if the current scope is reactive.
+*/
+function isInReactiveScope(reactivity) {
+	if (!reactivity) return false;
+	if (!reactivity.isInScope) return true;
+	return reactivity.isInScope();
+}
+/**
+* Represents a cursor for querying and observing a filtered, sorted, and transformed
+* subset of items from a collection. Supports reactivity and field tracking.
+* @template T - The type of the items in the collection.
+* @template E - The transformed item type after applying transformAll (default is T).
+* @template U - The transformed item type after applying transform (default is E).
+*/
+var Cursor = class {
+	observer;
+	getFilteredItems;
+	options;
+	onCleanupCallbacks = [];
+	/**
+	* Creates a new instance of the `Cursor` class.
+	* Provides utilities for querying, observing, and transforming items from a collection.
+	* @template T - The type of the items in the collection.
+	* @template U - The transformed item type after applying transformations (default is T).
+	* @param getItems - A function that retrieves the filtered list of items.
+	* @param options - Optional configuration for the cursor.
+	* @param options.transform - A transformation function to apply to each item when retrieving them.
+	* @param options.bindEvents - A function to bind reactivity events for the cursor, which should return a cleanup function.
+	* @param options.fields - A projection object defining which fields of the item should be included or excluded.
+	* @param options.sort - A sort specifier to determine the order of the items.
+	* @param options.skip - The number of items to skip from the beginning of the result set.
+	* @param options.limit - The maximum number of items to return in the result set.
+	* @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
+	* @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
+	* @param options.transformAll - A function that will be able to solve the n+1 problem
+	*/
+	constructor(getItems, options) {
+		this.getFilteredItems = getItems;
+		this.options = options || {};
+	}
+	addGetters(item) {
+		if (!isInReactiveScope(this.options.reactive)) return item;
+		const depend = this.depend.bind(this);
+		return Object.entries(item).reduce((memo, [key, value]) => {
+			Object.defineProperty(memo, key, {
+				get() {
+					depend({ changedField: (notify) => (changedItem, changedFieldName) => {
+						if (changedFieldName !== key || changedItem.id !== item.id) return;
+						notify();
+					} });
+					return value;
+				},
+				enumerable: true,
+				configurable: true
+			});
+			return memo;
+		}, {});
+	}
+	transform(rawItem) {
+		const item = this.options.fieldTracking ? this.addGetters(rawItem) : rawItem;
+		if (!this.options.transform) return item;
+		return this.options.transform(item);
+	}
+	getItems() {
+		const items = this.getFilteredItems();
+		const { sort, skip, limit, transformAll, fields } = this.options;
+		const sorted = sort ? require_sortItems.default(items, sort) : items;
+		const skipped = skip ? sorted.slice(skip) : sorted;
+		const limited = limit ? skipped.slice(0, limit) : skipped;
+		const idExcluded = this.options.fields && this.options.fields.id === 0;
+		let entries = limited;
+		if (transformAll) entries = transformAll(require_deepClone.default(limited), fields);
+		return entries.map((item) => {
+			if (!this.options.fields) return item;
+			return {
+				...idExcluded ? {} : { id: item.id },
+				...require_project.default(item, this.options.fields)
+			};
+		});
+	}
+	depend(changeEvents) {
+		if (!this.options.reactive) return;
+		if (!isInReactiveScope(this.options.reactive)) return;
+		const signal = this.options.reactive.create();
+		signal.depend();
+		const notify = () => signal.notify();
+		/**
+		* Builds a notifier function for the specified event.
+		* @template Event - The type of the event.
+		* @param event - The event for which to build the notifier.
+		* @returns A function that handles the event and triggers the appropriate notifications.
+		*/
+		function buildNotifier(event) {
+			const eventHandler = changeEvents[event];
+			return (...args) => {
+				if (eventHandler === true) {
+					notify();
+					return;
+				}
+				if (typeof eventHandler !== "function") return;
+				eventHandler(notify)(...args);
+			};
+		}
+		const stop = this.observeRawChanges({
+			added: buildNotifier("added"),
+			addedBefore: buildNotifier("addedBefore"),
+			changed: buildNotifier("changed"),
+			changedField: buildNotifier("changedField"),
+			movedBefore: buildNotifier("movedBefore"),
+			removed: buildNotifier("removed")
+		}, true);
+		if (this.options.reactive.onDispose) this.options.reactive.onDispose(() => stop(), signal);
+		this.onCleanup(stop);
+	}
+	ensureObserver() {
+		if (!this.observer) {
+			const observer = new require_Observer.default(() => {
+				const requery = () => {
+					observer.runChecks(this.getItems());
+				};
+				const cleanup = this.options.bindEvents && this.options.bindEvents(requery);
+				return () => {
+					if (cleanup) cleanup();
+				};
+			});
+			this.onCleanup(() => observer.stop());
+			this.observer = observer;
+		}
+		return this.observer;
+	}
+	observeRawChanges(callbacks, skipInitial = false) {
+		const observer = this.ensureObserver();
+		observer.addCallbacks(callbacks, skipInitial);
+		observer.runChecks(this.getItems());
+		return () => {
+			observer.removeCallbacks(callbacks);
+			if (!observer.isEmpty()) return;
+			observer.stop();
+			this.observer = void 0;
+		};
+	}
+	/**
+	* Cleans up all resources associated with the cursor, such as reactive bindings
+	* and event listeners. This method should be called when the cursor is no longer needed
+	* to prevent memory leaks.
+	*/
+	cleanup() {
+		this.onCleanupCallbacks.forEach((callback) => {
+			callback();
+		});
+		this.onCleanupCallbacks = [];
+	}
+	/**
+	* Registers a cleanup callback to be executed when the `cleanup` method is called.
+	* Useful for managing resources and ensuring proper cleanup of bindings or listeners.
+	* @param callback - A function to be executed during cleanup.
+	*/
+	onCleanup(callback) {
+		this.onCleanupCallbacks.push(callback);
+	}
+	/**
+	* Iterates over each item in the cursor's result set, applying the provided callback
+	* function to each transformed item.
+	* ⚡️ this function is reactive!
+	* @param callback - A function to execute for each item in the result set.
+	* @param callback.item - The transformed item.
+	*/
+	forEach(callback) {
+		const items = this.getItems();
+		this.depend({
+			addedBefore: true,
+			removed: true,
+			movedBefore: true,
+			...this.options.fieldTracking ? {} : { changed: true }
+		});
+		items.forEach((item) => {
+			callback(this.transform(item));
+		});
+	}
+	/**
+	* Creates a new array populated with the results of applying the provided callback
+	* function to each transformed item in the cursor's result set.
+	* ⚡️ this function is reactive!
+	* @template V - The type of the items in the resulting array.
+	* @param callback - A function to execute for each item in the result set.
+	* @param callback.item - The transformed item.
+	* @returns An array of results after applying the callback to each item.
+	*/
+	map(callback) {
+		const results = [];
+		this.forEach((item) => {
+			results.push(callback(item));
+		});
+		return results;
+	}
+	/**
+	* Fetches all transformed items from the cursor's result set as an array.
+	* Automatically applies filtering, sorting, and limiting as per the cursor's options.
+	* ⚡️ this function is reactive!
+	* @returns An array of transformed items in the result set.
+	*/
+	fetch() {
+		return this.map((item) => item);
+	}
+	/**
+	* Counts the total number of items in the cursor's result set after applying
+	* filtering and other criteria.
+	* ⚡️ this function is reactive!
+	* @returns The total number of items in the result set.
+	*/
+	count() {
+		const items = this.getItems();
+		this.depend({
+			added: true,
+			removed: true
+		});
+		return items.length;
+	}
+	/**
+	* Observes changes to the cursor's result set and triggers the specified callbacks
+	* when items are added, removed, or updated. Supports reactivity and transformation.
+	* @param callbacks - An object containing the callback functions to handle different change events.
+	* @param callbacks.added - Triggered when an item is added to the result set.
+	* @param callbacks.removed - Triggered when an item is removed from the result set.
+	* @param callbacks.changed - Triggered when an item in the result set is modified.
+	* @param callbacks.addedBefore - Triggered when an item is added before another item in the result set.
+	* @param callbacks.movedBefore - Triggered when an item is moved before another item in the result set.
+	* @param callbacks.changedField - Triggered when a specific field of an item changes.
+	* @param skipInitial - A boolean indicating whether to skip the initial notification of the current result set.
+	* @returns A function to stop observing changes.
+	*/
+	observeChanges(callbacks, skipInitial = false) {
+		return this.observeRawChanges(Object.entries(callbacks).reduce((memo, [callbackName, callback]) => {
+			if (!callback) return memo;
+			return {
+				...memo,
+				[callbackName]: (item, before) => {
+					const transformedValue = this.transform(item);
+					const hasBeforeParameter = before !== void 0;
+					const transformedBeforeValue = hasBeforeParameter && before ? this.transform(before) : null;
+					return callback(transformedValue, ...hasBeforeParameter ? [transformedBeforeValue] : []);
+				}
+			};
+		}, {}), skipInitial);
+	}
+	/**
+	* Forces the cursor to re-evaluate its result set by re-fetching items
+	* from the collection. This is useful when the underlying data or query
+	* criteria have changed, and you want to ensure the cursor reflects the latest state.
+	*/
+	requery() {
+		if (!this.observer) return;
+		this.observer.runChecks(this.getItems());
+	}
+};
+//#endregion
+exports.default = Cursor;

package/dist/index10.mjs

@@ -1,30 +1,265 @@
-function isEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a instanceof RegExp && b instanceof RegExp)
-    return a.toString() === b.toString();
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (typeof a !== "object")
-    return false;
-  if (typeof b !== "object")
-    return false;
-  if (a === null)
-    return false;
-  if (b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (const key of aKeys) {
-    if (!bKeys.includes(key))
-      return false;
-    if (!isEqual(a[key], b[key]))
-      return false;
-  }
-  return true;
+import sortItems from "./index3.mjs";
+import project from "./index5.mjs";
+import deepClone from "./index6.mjs";
+import Observer from "./index9.mjs";
+//#region src/Collection/Cursor.ts
+/**
+* Checks if the current scope is reactive, considering the provided reactivity adapter.
+* @param reactivity - The reactivity adapter or a boolean indicating whether reactivity is enabled.
+* @returns A boolean indicating if the current scope is reactive.
+*/
+function isInReactiveScope(reactivity) {
+	if (!reactivity) return false;
+	if (!reactivity.isInScope) return true;
+	return reactivity.isInScope();
 }
-export {
-  isEqual as default
+/**
+* Represents a cursor for querying and observing a filtered, sorted, and transformed
+* subset of items from a collection. Supports reactivity and field tracking.
+* @template T - The type of the items in the collection.
+* @template E - The transformed item type after applying transformAll (default is T).
+* @template U - The transformed item type after applying transform (default is E).
+*/
+var Cursor = class {
+	observer;
+	getFilteredItems;
+	options;
+	onCleanupCallbacks = [];
+	/**
+	* Creates a new instance of the `Cursor` class.
+	* Provides utilities for querying, observing, and transforming items from a collection.
+	* @template T - The type of the items in the collection.
+	* @template U - The transformed item type after applying transformations (default is T).
+	* @param getItems - A function that retrieves the filtered list of items.
+	* @param options - Optional configuration for the cursor.
+	* @param options.transform - A transformation function to apply to each item when retrieving them.
+	* @param options.bindEvents - A function to bind reactivity events for the cursor, which should return a cleanup function.
+	* @param options.fields - A projection object defining which fields of the item should be included or excluded.
+	* @param options.sort - A sort specifier to determine the order of the items.
+	* @param options.skip - The number of items to skip from the beginning of the result set.
+	* @param options.limit - The maximum number of items to return in the result set.
+	* @param options.reactive - A reactivity adapter to enable observing changes in the cursor's result set.
+	* @param options.fieldTracking - A boolean to enable fine-grained field tracking for reactivity.
+	* @param options.transformAll - A function that will be able to solve the n+1 problem
+	*/
+	constructor(getItems, options) {
+		this.getFilteredItems = getItems;
+		this.options = options || {};
+	}
+	addGetters(item) {
+		if (!isInReactiveScope(this.options.reactive)) return item;
+		const depend = this.depend.bind(this);
+		return Object.entries(item).reduce((memo, [key, value]) => {
+			Object.defineProperty(memo, key, {
+				get() {
+					depend({ changedField: (notify) => (changedItem, changedFieldName) => {
+						if (changedFieldName !== key || changedItem.id !== item.id) return;
+						notify();
+					} });
+					return value;
+				},
+				enumerable: true,
+				configurable: true
+			});
+			return memo;
+		}, {});
+	}
+	transform(rawItem) {
+		const item = this.options.fieldTracking ? this.addGetters(rawItem) : rawItem;
+		if (!this.options.transform) return item;
+		return this.options.transform(item);
+	}
+	getItems() {
+		const items = this.getFilteredItems();
+		const { sort, skip, limit, transformAll, fields } = this.options;
+		const sorted = sort ? sortItems(items, sort) : items;
+		const skipped = skip ? sorted.slice(skip) : sorted;
+		const limited = limit ? skipped.slice(0, limit) : skipped;
+		const idExcluded = this.options.fields && this.options.fields.id === 0;
+		let entries = limited;
+		if (transformAll) entries = transformAll(deepClone(limited), fields);
+		return entries.map((item) => {
+			if (!this.options.fields) return item;
+			return {
+				...idExcluded ? {} : { id: item.id },
+				...project(item, this.options.fields)
+			};
+		});
+	}
+	depend(changeEvents) {
+		if (!this.options.reactive) return;
+		if (!isInReactiveScope(this.options.reactive)) return;
+		const signal = this.options.reactive.create();
+		signal.depend();
+		const notify = () => signal.notify();
+		/**
+		* Builds a notifier function for the specified event.
+		* @template Event - The type of the event.
+		* @param event - The event for which to build the notifier.
+		* @returns A function that handles the event and triggers the appropriate notifications.
+		*/
+		function buildNotifier(event) {
+			const eventHandler = changeEvents[event];
+			return (...args) => {
+				if (eventHandler === true) {
+					notify();
+					return;
+				}
+				if (typeof eventHandler !== "function") return;
+				eventHandler(notify)(...args);
+			};
+		}
+		const stop = this.observeRawChanges({
+			added: buildNotifier("added"),
+			addedBefore: buildNotifier("addedBefore"),
+			changed: buildNotifier("changed"),
+			changedField: buildNotifier("changedField"),
+			movedBefore: buildNotifier("movedBefore"),
+			removed: buildNotifier("removed")
+		}, true);
+		if (this.options.reactive.onDispose) this.options.reactive.onDispose(() => stop(), signal);
+		this.onCleanup(stop);
+	}
+	ensureObserver() {
+		if (!this.observer) {
+			const observer = new Observer(() => {
+				const requery = () => {
+					observer.runChecks(this.getItems());
+				};
+				const cleanup = this.options.bindEvents && this.options.bindEvents(requery);
+				return () => {
+					if (cleanup) cleanup();
+				};
+			});
+			this.onCleanup(() => observer.stop());
+			this.observer = observer;
+		}
+		return this.observer;
+	}
+	observeRawChanges(callbacks, skipInitial = false) {
+		const observer = this.ensureObserver();
+		observer.addCallbacks(callbacks, skipInitial);
+		observer.runChecks(this.getItems());
+		return () => {
+			observer.removeCallbacks(callbacks);
+			if (!observer.isEmpty()) return;
+			observer.stop();
+			this.observer = void 0;
+		};
+	}
+	/**
+	* Cleans up all resources associated with the cursor, such as reactive bindings
+	* and event listeners. This method should be called when the cursor is no longer needed
+	* to prevent memory leaks.
+	*/
+	cleanup() {
+		this.onCleanupCallbacks.forEach((callback) => {
+			callback();
+		});
+		this.onCleanupCallbacks = [];
+	}
+	/**
+	* Registers a cleanup callback to be executed when the `cleanup` method is called.
+	* Useful for managing resources and ensuring proper cleanup of bindings or listeners.
+	* @param callback - A function to be executed during cleanup.
+	*/
+	onCleanup(callback) {
+		this.onCleanupCallbacks.push(callback);
+	}
+	/**
+	* Iterates over each item in the cursor's result set, applying the provided callback
+	* function to each transformed item.
+	* ⚡️ this function is reactive!
+	* @param callback - A function to execute for each item in the result set.
+	* @param callback.item - The transformed item.
+	*/
+	forEach(callback) {
+		const items = this.getItems();
+		this.depend({
+			addedBefore: true,
+			removed: true,
+			movedBefore: true,
+			...this.options.fieldTracking ? {} : { changed: true }
+		});
+		items.forEach((item) => {
+			callback(this.transform(item));
+		});
+	}
+	/**
+	* Creates a new array populated with the results of applying the provided callback
+	* function to each transformed item in the cursor's result set.
+	* ⚡️ this function is reactive!
+	* @template V - The type of the items in the resulting array.
+	* @param callback - A function to execute for each item in the result set.
+	* @param callback.item - The transformed item.
+	* @returns An array of results after applying the callback to each item.
+	*/
+	map(callback) {
+		const results = [];
+		this.forEach((item) => {
+			results.push(callback(item));
+		});
+		return results;
+	}
+	/**
+	* Fetches all transformed items from the cursor's result set as an array.
+	* Automatically applies filtering, sorting, and limiting as per the cursor's options.
+	* ⚡️ this function is reactive!
+	* @returns An array of transformed items in the result set.
+	*/
+	fetch() {
+		return this.map((item) => item);
+	}
+	/**
+	* Counts the total number of items in the cursor's result set after applying
+	* filtering and other criteria.
+	* ⚡️ this function is reactive!
+	* @returns The total number of items in the result set.
+	*/
+	count() {
+		const items = this.getItems();
+		this.depend({
+			added: true,
+			removed: true
+		});
+		return items.length;
+	}
+	/**
+	* Observes changes to the cursor's result set and triggers the specified callbacks
+	* when items are added, removed, or updated. Supports reactivity and transformation.
+	* @param callbacks - An object containing the callback functions to handle different change events.
+	* @param callbacks.added - Triggered when an item is added to the result set.
+	* @param callbacks.removed - Triggered when an item is removed from the result set.
+	* @param callbacks.changed - Triggered when an item in the result set is modified.
+	* @param callbacks.addedBefore - Triggered when an item is added before another item in the result set.
+	* @param callbacks.movedBefore - Triggered when an item is moved before another item in the result set.
+	* @param callbacks.changedField - Triggered when a specific field of an item changes.
+	* @param skipInitial - A boolean indicating whether to skip the initial notification of the current result set.
+	* @returns A function to stop observing changes.
+	*/
+	observeChanges(callbacks, skipInitial = false) {
+		return this.observeRawChanges(Object.entries(callbacks).reduce((memo, [callbackName, callback]) => {
+			if (!callback) return memo;
+			return {
+				...memo,
+				[callbackName]: (item, before) => {
+					const transformedValue = this.transform(item);
+					const hasBeforeParameter = before !== void 0;
+					const transformedBeforeValue = hasBeforeParameter && before ? this.transform(before) : null;
+					return callback(transformedValue, ...hasBeforeParameter ? [transformedBeforeValue] : []);
+				}
+			};
+		}, {}), skipInitial);
+	}
+	/**
+	* Forces the cursor to re-evaluate its result set by re-fetching items
+	* from the collection. This is useful when the underlying data or query
+	* criteria have changed, and you want to ensure the cursor reflects the latest state.
+	*/
+	requery() {
+		if (!this.observer) return;
+		this.observer.runChecks(this.getItems());
+	}
 };
+//#endregion
+export { Cursor as default };

package/dist/index11.cjs.js

@@ -0,0 +1,125 @@
+//#region src/utils/EventEmitter.ts
+/**
+* A strongly‑typed EventEmitter.
+*/
+var EventEmitter = class {
+	_maxListeners = 100;
+	/**
+	* We store a set of the listeners for each event.
+	*/
+	_listenerStore = /* @__PURE__ */ new Map();
+	setMaxListeners(max) {
+		this._maxListeners = max;
+		return this;
+	}
+	/**
+	* Subscribe to an event with a listener function.
+	* @param eventName The event name (key of E).
+	* @param listener  A function that receives the emitted arguments.
+	* @returns         The emitter instance (for chaining).
+	*/
+	on(eventName, listener) {
+		let listenersSet = this._listenerStore.get(eventName);
+		if (!listenersSet) {
+			listenersSet = /* @__PURE__ */ new Set();
+			this._listenerStore.set(eventName, listenersSet);
+		}
+		listenersSet.add(listener);
+		if (listenersSet.size > this._maxListeners) console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
+		return this;
+	}
+	/**
+	* Subscribe to an event with a listener function.
+	* @param eventName The event name (key of E).
+	* @param listener  A function that receives the emitted arguments.
+	* @returns         The emitter instance (for chaining).
+	*/
+	addListener(eventName, listener) {
+		return this.on(eventName, listener);
+	}
+	/**
+	* Subscribe to an event, handling it only once. Automatically removes
+	* the listener after it fires the first time.
+	* @param eventName The event name (key of E).
+	* @param listener  A function that receives the emitted arguments.
+	* @returns         The emitter instance (for chaining).
+	*/
+	once(eventName, listener) {
+		const onceWrapper = ((...args) => {
+			listener(...args);
+			this.off(eventName, onceWrapper);
+		});
+		return this.on(eventName, onceWrapper);
+	}
+	/**
+	* Unsubscribe a previously subscribed listener.
+	* @param eventName The event name (key of E).
+	* @param listener  The original function passed to `on` or `once`.
+	* @returns         The emitter instance (for chaining).
+	*/
+	off(eventName, listener) {
+		const listenersSet = this._listenerStore.get(eventName);
+		if (!listenersSet) return this;
+		listenersSet.delete(listener);
+		if (listenersSet.size === 0) this._listenerStore.delete(eventName);
+		return this;
+	}
+	/**
+	* Unsubscribe a previously subscribed listener.
+	* @param eventName The event name (key of E).
+	* @param listener  The original function passed to `on` or `once`.
+	* @returns         The emitter instance (for chaining).
+	*/
+	removeListener(eventName, listener) {
+		return this.off(eventName, listener);
+	}
+	/**
+	* Emit (dispatch) an event with a variable number of arguments.
+	* @param eventName The event name (key of E).
+	* @param args      The arguments to pass to subscribed listeners.
+	*/
+	emit(eventName, ...args) {
+		this.listeners(eventName).forEach((listener) => {
+			listener(...args);
+		});
+	}
+	/**
+	* Returns the array of listener functions currently registered for a given event.
+	* @param eventName The event name (key of E).
+	* @returns         An array of listener functions.
+	*/
+	listeners(eventName) {
+		const listenersSet = this._listenerStore.get(eventName);
+		if (!listenersSet) return [];
+		return [...listenersSet.values()];
+	}
+	/**
+	* Returns the number of listeners for a given event.
+	* @param eventName The event name (key of E).
+	* @returns         The number of listeners.
+	*/
+	listenerCount(eventName) {
+		const listenersSet = this._listenerStore.get(eventName);
+		return listenersSet ? listenersSet.size : 0;
+	}
+	/**
+	* Removes all listeners for a given event, or all events if none is specified.
+	* @param eventName Optional. If omitted, clears all events’ listeners.
+	* @returns         The emitter instance (for chaining).
+	*/
+	removeAllListeners(eventName) {
+		if (eventName === void 0) {
+			for (const [eventName_, listenersSet] of this._listenerStore.entries()) for (const listener of listenersSet.values()) this.off(eventName_, listener);
+			this._listenerStore.clear();
+		} else {
+			const listenersSet = this._listenerStore.get(eventName);
+			if (listenersSet) {
+				for (const listener of listenersSet.values()) this.off(eventName, listener);
+				this._listenerStore.delete(eventName);
+			}
+		}
+		return this;
+	}
+};
+//#endregion
+exports.default = EventEmitter;