@irrelon/emitter 5.0.0 → 5.0.2

package/.eslintignore

@@ -1,3 +1 @@
-node_modules
-dist
-doc
+node_modules

package/.eslintrc.json

@@ -1,24 +1,41 @@
 {
-	"parser": "@typescript-eslint/parser",
-	"plugins": ["@typescript-eslint"],
 	"extends": [
-		"eslint:recommended",
-		"eslint-config-irrelon",
-		"plugin:@typescript-eslint/eslint-recommended",
+		"prettier",
 		"plugin:@typescript-eslint/recommended"
 	],
-	"globals": {
-		"document": true,
-		"window": true,
-		"process": true
-	},
-	"env": {
-		"browser": true,
-		"node": true,
-		"es6": true
-	},
+	"plugins": [
+		"prettier",
+		"@typescript-eslint",
+		"unused-imports",
+		"tree-shaking"
+	],
 	"rules": {
-		"semi": "error",
-		"@typescript-eslint/no-explicit-any": 0
+		"@typescript-eslint/no-unnecessary-type-assertion": "off",
+		"@typescript-eslint/consistent-type-definitions": "off",
+		"@typescript-eslint/no-empty-interface": "off",
+		"@typescript-eslint/no-empty-arrow-function": "off",
+		"@typescript-eslint/no-empty-function": "off",
+		"@typescript-eslint/no-inferrable-types": "off",
+		"@typescript-eslint/strict-boolean-expressions": "off",
+		"@typescript-eslint/ban-ts-comment": "off",
+		"@typescript-eslint/no-this-alias": "off",
+		"@typescript-eslint/no-explicit-any": "off",
+		"@typescript-eslint/no-shadow": "error",
+		"unused-imports/no-unused-imports": "warn",
+		"indent": ["error", "tab"],
+		"space-before-function-paren": [
+			"error",
+			"always"
+		],
+		"no-shadow": "off",
+		"complexity": [
+			"warn",
+			20
+		],
+		"max-depth": [
+			"warn",
+			4
+		],
+		"prefer-rest-params": "off"
 	}
-}
+}

package/.prettierignore

@@ -0,0 +1,9 @@
+artifacts
+cache
+node_modules
+.next
+yarn.lock
+package-lock.json
+public
+.yarn
+.yarnrc

package/.prettierrc.yml

@@ -0,0 +1,9 @@
+trailingComma: "none"
+tabWidth: 4
+printWidth: 140
+semi: true
+singleQuote: false
+arrowParens: always
+bracketSpacing: true
+bracketSameLine: false
+jsxSingleQuote: false

package/fixPaths.cjs

@@ -0,0 +1,183 @@
+/**
+ * A very basic search and replace function to find import and export statements
+ * in .js files where the path of the file being specified does not have a .js
+ * extension and replace those paths with one that has a .js extension.
+ *
+ * This would be much better written using abstract source trees to do the
+ * re-writing which would be "safer", however this is a fully working function
+ * and doesn't seem to mess anything up at present.
+ */
+const chokidar = require("chokidar");
+const fs = require("fs");
+const { readFile, writeFile, readdir } = require("fs").promises;
+const { resolve } = require("path");
+const { minimatch } = require("minimatch");
+
+const matchPattern = ["**/*.js", "**/*.jsx"];
+const excludePattern = ["node_modules", "react", ".git"];
+
+const expressions = [{
+	exp: /import(.*)?["']([.]+)(((?!\.js).)*?)["'];/g,
+	update: (match, isIndex) => {
+		if (isIndex) {
+			return `import${match[1]}"${match[2]}${match[3]}/index.js";`;
+		}
+
+		return `import${match[1]}"${match[2]}${match[3]}.js";`;
+	}
+}, {
+	exp: /export\s(.*)?\sfrom\s["']([.]+)(((?!\.js).)*?)["'];/g,
+	update: (match, isIndex) => {
+		if (isIndex) {
+			return `export ${match[1]} from "${match[2]}${match[3]}/index.js";`;
+		}
+
+		return `export ${match[1]} from "${match[2]}${match[3]}.js";`;
+	}
+}];
+
+let tsPaths = {};
+let tsResolvedPaths = {};
+
+const readTsConfig = () => {
+	const config = require("./tsconfig.json");
+	tsPaths = config.compilerOptions.paths;
+
+	Object.entries(tsPaths).forEach(([key, replacementArr]) => {
+		tsResolvedPaths[key] = replacementArr.map((dir) => {
+			return resolve(__dirname, dir);
+		});
+	});
+};
+
+async function getFiles (dir, gitIgnoreArr) {
+	const dirArr = await readdir(dir, { withFileTypes: true });
+
+	const finalList = dirArr.filter((filePath) => {
+		return excludePattern.every((glob) => !minimatch(filePath.name, glob));
+	});
+
+	const files = await Promise.all(finalList.map((tmpDir) => {
+		const res = resolve(dir, tmpDir.name);
+		return tmpDir.isDirectory() ? getFiles(res) : [res];
+	})).then((results) => {
+		return results.reduce((arr, item) => {
+			arr.push(...item);
+			return arr;
+		}, []);
+	});
+
+	const finalFiles = files.filter((file) => {
+		if (!file || !file.trim()) return false;
+		return matchPattern.some((glob) => minimatch(file, glob));
+	});
+
+	return Array.prototype.concat(...finalFiles);
+}
+
+const processMatches = (regExp, fileFolder, content, updateFunc) => {
+	let match;
+	while (match = regExp.exec(content)) {
+		const pathToItemFile = resolve(fileFolder, match[2] + match[3] + ".js");
+		const pathToItemFolderIndexFile = resolve(fileFolder, match[2] + match[3] + "/index.js");
+		let pathStatFile;
+		let pathStatFolderIndexFile;
+
+		try {
+			pathStatFile = fs.lstatSync(pathToItemFile);
+		} catch (err) {
+			pathStatFolderIndexFile = undefined;
+		}
+
+		try {
+			pathStatFolderIndexFile = fs.lstatSync(pathToItemFolderIndexFile);
+		} catch (err) {
+			pathStatFolderIndexFile = undefined;
+		}
+
+		if (pathStatFile) {
+			// Just add .js to the end of the path
+			content = content.replace(match[0], updateFunc(match, false));
+		} else if (pathStatFolderIndexFile) {
+			content = content.replace(match[0], updateFunc(match, true));
+		}
+	}
+
+	return content;
+};
+
+const processFile = (file) => {
+	if (!file) return;
+
+	//console.log(`Processing ${file}...`);
+
+	readFile(file).then((fileContentsBuffer) => {
+		const fileFolderArr = file.split("/");
+		fileFolderArr.pop();
+
+		const fileFolder = fileFolderArr.join("/");
+
+		const fileContent = fileContentsBuffer.toString();
+		let updatedContent = fileContent;
+
+		Object.entries(tsPaths).forEach(([key, replacementArr]) => {
+			const find = key.replace("*", "");
+			const replace = replacementArr[0].replace("*", "");
+
+			const relativeSteps = new Array(file.replace(__dirname, "").split("/").length - 2).fill("../").join("");
+			const replacementPath = relativeSteps + replace;
+
+			updatedContent = updatedContent.replaceAll(find, replacementPath);
+		});
+
+		expressions.forEach((expression) => {
+			updatedContent = processMatches(expression.exp, fileFolder, updatedContent, expression.update);
+			expression.exp.lastIndex = 0;
+		})
+
+		if (fileContent === updatedContent) {
+			//console.log(`No change ${file}`);
+			return;
+		}
+
+		writeFile(file, updatedContent).then(() => {
+			console.log(`Updated ${file}`);
+		});
+	});
+};
+
+const runSearchReplace = () => {
+	// Scan all folders
+	readFile(resolve(__dirname, ".gitignore")).then((result) => {
+		return result.toString().split("\n").filter((line) => {
+			return !line.startsWith("#");
+		}).filter((line) => {
+			return Boolean(line.trim());
+		});
+	}).then((gitIgnoreArr) => {
+		return getFiles(__dirname, gitIgnoreArr);
+	}).then((files) => {
+		// Now scan the files for matching regular expressions
+		// of imports without extensions
+		files.forEach((file) => {
+			processFile(file);
+		});
+
+		console.log(`Processed ${files.length} files`);
+	});
+};
+
+readTsConfig();
+runSearchReplace();
+
+const watcher = chokidar.watch(__dirname, { persistent: true });
+
+watcher.on("change", (filename) => {
+	if (filename.indexOf("tsconfig.json") > -1) {
+		console.log("Updating tsconfig.json data");
+		readTsConfig();
+	}
+	if (!matchPattern.some((glob) => minimatch(filename, glob))) return;
+	//console.log("Changed", filename);
+	processFile(filename);
+});

package/package.json

@@ -2,7 +2,8 @@
 	"author": "Rob Evans - Irrelon Software Limited",
 	"name": "@irrelon/emitter",
 	"description": "Simple JavaScript event emitter.",
-	"version": "5.0.0",
+	"version": "5.0.2",
+	"type": "module",
 	"keywords": [
 		"javascript",
 		"browser",
@@ -17,39 +18,45 @@
 		"listener"
 	],
 	"devDependencies": {
-		"@babel/cli": "^7.8.7",
-		"@babel/core": "^7.8.7",
-		"@babel/plugin-proposal-class-properties": "^7.8.7",
-		"@babel/plugin-proposal-object-rest-spread": "^7.8.7",
-		"@babel/plugin-transform-runtime": "^7.8.7",
-		"@babel/preset-env": "^7.8.7",
-		"@babel/preset-react": "^7.8.7",
-		"@babel/register": "^7.8.7",
-		"@types/node": "^16.11.6",
-		"@typescript-eslint/eslint-plugin": "^5.4.0",
-		"@typescript-eslint/parser": "^5.4.0",
-		"eslint": "^7.32.0",
-		"eslint-config-irrelon": "^1.0.2",
-		"jest": "^27.3.1",
-		"nodemon": "^2.0.3",
-		"rimraf": "^2.7.1",
-		"ts-node": "^10.4.0",
-		"typescript": "^4.4.4"
+		"@babel/polyfill": "^7.2.5",
+		"@babel/runtime": "^7.3.1",
+		"@types/jest": "^29.5.0",
+		"@types/node": "^18.7.23",
+		"@typescript-eslint/eslint-plugin": "^5.38.1",
+		"@typescript-eslint/parser": "^5.38.1",
+		"chokidar": "^3.5.3",
+		"eslint": "8.22.0",
+		"eslint-config-prettier": "^8.5.0",
+		"eslint-config-standard-with-typescript": "^23.0.0",
+		"eslint-plugin-import": "^2.26.0",
+		"eslint-plugin-jest": "^27.0.4",
+		"eslint-plugin-node": "^11.1.0",
+		"eslint-plugin-prettier": "^4.2.1",
+		"eslint-plugin-promise": "^6.0.1",
+		"eslint-plugin-standard": "^5.0.0",
+		"eslint-plugin-tree-shaking": "^1.10.0",
+		"eslint-plugin-unused-imports": "^2.0.0",
+		"jest": "^29.1.1",
+		"minimatch": "^7.4.2",
+		"prettier": "^2.7.1",
+		"ts-jest": "^29.0.2",
+		"typescript": "^4.8.4"
 	},
 	"engines": {
 		"node": "*"
 	},
 	"scripts": {
-		"test": "NODE_ENV=test npm run build && jest ./tests",
-		"testMon": "nodemon --watch src --watch tests --exec \"NODE_ENV=test BABEL_DISABLE_CACHE=1 jest ./tests\"",
-		"build": "rimraf dist && tsc"
+		"build": "tsc",
+		"build-watch": "tsc --watch",
+		"fixPaths": "node fixPaths.cjs",
+		"test": "NODE_OPTIONS=--experimental-vm-modules npx jest --testMatch \"**/*.test.js\"",
+		"test-watch": "NODE_OPTIONS=--experimental-vm-modules npx jest --testMatch \"**/*.test.js\" --watchAll"
 	},
-	"types": "./dist/Emitter.d.ts",
 	"repository": {
 		"type": "git",
 		"url": "git://github.com/irrelon/emitter.git"
 	},
-	"main": "./dist/Emitter.js",
+	"main": "src/Emitter.js",
 	"bugs": {
 		"url": "https://github.com/irrelon/emitter/issues"
 	}

package/readme.md

@@ -3,74 +3,45 @@
 ## Usage
 
 ### Browser
-Include the ./dist/Emitter.js file in your HTML
+Include the ./dist/index.min.js file in your HTML
 
 ```html
-<script src="./dist/Emitter.js"></script>
+<script src="./dist/index.min.js"></script>
 ```
 
 ### Node.js
-Install via NPM:
+Install via NPM / Yarn:
 
 ```bash
 npm install @irrelon/emitter
 ```
 
+```bash
+yarn add @irrelon/emitter
+```
+
 Include in your application:
 
 ```js
-import {Emitter, makeEmitter} from "@irrelon/emitter";
+var Emitter = require('@irrelon/emitter');
 ```
 
-## Create a New Standalone Emitter
-```js
-const emitter = new Emitter();
-
-emitter.on("foo", () => {
-	console.log("foo emitted!");
-});
-
-emitter.emit("foo!");
-```
+## Add Emitter Functionality to Existing Class
+Given an example class:
 
-## Add Emitter Functionality to an Object
 ```js
-const obj = {
-	someExistingProp: "hello"
+var MyClass = function () {
+	this.emit('myEvent', myData, myOtherData);
 };
-makeEmitter(obj);
-
-obj.on("someEvent", function (data) {
-	// do something when the event is emitted
-	if (data.someData === true) {
-		console.log(this.someExistingProp); // Will output "hello" because `this` has been applied as `obj` in context
-	}
-});
-
-obj.emit("someEvent", {someData: true});
 ```
 
-## Add Emitter Functionality to Existing Class
-```js
-class MyClass {
-	constructor () {
-		console.log("I created a class instance!");
-	}
-} 
-
-makeEmitter(MyClass.prototype); // Notice we use prototype here!
-
-const myNewClassInstance = new MyClass();
+Add emitter functionality:
 
-myNewClassInstance.on("someEvent", () => {
-	// do something when the event is emitted
-});
-
-myNewClassInstance.emit("someEvent", {someData: true});
+```js
+Emitter(MyClass);
 ```
 
-## The Emitter Methods
-Your object or class is given these new methods/functions:
+Your class now inherits the emitter methods:
 
 * on
 * off

package/src/Emitter.d.ts

@@ -0,0 +1,190 @@
+export declare enum EventReturnFlag {
+    none = 0,
+    cancel = 1
+}
+export declare type EventListenerCallback = (...args: any[]) => any | Promise<any>;
+export interface EventStaticEmitterObject {
+    id: string;
+    args: any[];
+}
+/**
+ * Creates a new class with the capability to emit events.
+ */
+export declare class Emitter {
+    _eventsEmitting: boolean;
+    _eventRemovalQueue: any[];
+    _eventListeners?: Record<string, Record<string, EventListenerCallback[]>>;
+    _eventStaticEmitters: Record<string, EventStaticEmitterObject[]>;
+    _eventsAllowDefer: boolean;
+    _eventsDeferTimeouts: Record<any, number>;
+    /**
+     * Attach an event listener to the passed event only if the passed
+     * id matches the id for the event being fired.
+     * @param {string} eventName The name of the event to listen for.
+     * @param {string} id The id to match against.
+     * @param {function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
+     */
+    _on(eventName: string, id: string, listener: EventListenerCallback): this;
+    /**
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param {String} eventName The name of the event to listen for.
+     * @param {*} id The id to match against.
+     * @param {Function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
+     */
+    _once(eventName: string, id: string, listener: EventListenerCallback): this;
+    /**
+     * Cancels an event listener based on an event name, id and listener function.
+     * @param {String} eventName The event to cancel listener for.
+     * @param {String} id The ID of the event to cancel listening for.
+     * @param {Function} listener The event listener function used in the on()
+     * or once() call to cancel.
+     * @returns {Emitter} The emitter instance.
+     */
+    _off(eventName: string, id: string, listener?: EventListenerCallback): this;
+    /**
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param {String} eventName The name of the event to listen for.
+     * @param {*} id The id to match against.
+     * @param {Function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
+     */
+    on(eventName: string, id: string, listener: EventListenerCallback): this;
+    on(eventName: string, listener: EventListenerCallback): this;
+    /**
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param {String} eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener
+     * @returns {Emitter} The emitter instance.
+     */
+    once(eventName: string, id: string, listener: EventListenerCallback): this;
+    once(eventName: string, listener: EventListenerCallback): this;
+    /**
+     * Overwrites any previous event listeners so that if the event fires, only
+     * the listener you pass will be called. If you pass an id along with the
+     * listener, only listeners for the id will be overwritten. This is similar
+     * to calling `.off(eventName)` then `on(eventName, listener)` since
+     * `off(eventName)` will cancel any previous event listeners for the passed
+     * event name.
+     * @param {String} eventName The name of the event to listen for.
+     * @param {*} id The id to match against.
+     * @param {Function} listener The method to call when the event is fired.
+     * @returns {Emitter} The emitter instance.
+     */
+    overwrite(eventName: string, id: string, listener: EventListenerCallback): this;
+    overwrite(eventName: string, listener: EventListenerCallback): this;
+    /**
+     * Cancels an event listener based on an event name, id and listener function.
+     * @param {String} eventName The event to cancel listener for.
+     * @param {String} id The ID of the event to cancel listening for.
+     * @param {Function} listener The event listener function used in the on()
+     * or once() call to cancel.
+     * @returns {Emitter} The emitter instance.
+     */
+    off(eventName: string, id: string, listener?: EventListenerCallback): this;
+    off(eventName: string, listener?: EventListenerCallback): this;
+    off(eventName: string): this;
+    /**
+     * Emit an event by name.
+     * @param {Object} eventName The name of the event to emit.
+     * @param {...any} data The arguments to send to any listening methods.
+     * If you are sending multiple arguments, separate them with a comma so
+     * that they are received by the function as separate arguments.
+     * @return {number}
+     * @example #Emit an Event
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello');
+     * @example #Emit an Event With Data Object
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello', {moo: true});
+     * @example #Emit an Event With Multiple Data Values
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello', {moo: true}, 'someString');
+     * @example #Listen for Event Data
+     *     // Set a listener to listen for the data (multiple values emitted
+     *     // from an event are passed as function arguments)
+     *     myEntity.on('hello', function (arg1, arg2) {
+     *         console.log(arg1, arg2);
+     *     }
+     *
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello', 'data1', 'data2');
+     *
+     *     // The console output is:
+     *     //    data1, data2
+     */
+    emit(eventName: string, ...data: any[]): Promise<EventReturnFlag>;
+    emitId(eventName: string, id: string, ...data: any[]): EventReturnFlag;
+    /**
+     * Creates a persistent emitter record that will fire a listener if
+     * one is added for this event after the emitStatic() call has been
+     * made.
+     * @param {String} eventName The name of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns {Emitter} The emitter instance.
+     * @private
+     */
+    emitStatic(eventName: string, ...data: any[]): this;
+    /**
+     * Creates a persistent emitter record that will fire a listener if
+     * one is added for this event after the emitStatic() call has been
+     * made.
+     * @param {String} eventName The name of the event to emit.
+     * @param {String} id The id of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns {Emitter} The emitter instance.
+     * @private
+     */
+    emitStaticId(eventName: string, id: string, ...data: any[]): this;
+    /**
+     * Handles removing emitters, is an internal method not called directly.
+     * @param {String} eventName The event to remove static emitter for.
+     * @returns {Emitter} The emitter instance.
+     * @private
+     */
+    cancelStatic(eventName: string): this;
+    /**
+     * Checks if an event has any event listeners or not.
+     * @param {String} eventName The name of the event to check for.
+     * @returns {boolean} True if one or more event listeners are registered for
+     * the event. False if none are found.
+     */
+    willEmit(eventName: string): boolean;
+    /**
+     * Checks if an event has any event listeners or not based on the passed id.
+     * @param {String} eventName The name of the event to check for.
+     * @param {String} id The event ID to check for.
+     * @returns {boolean} True if one or more event listeners are registered for
+     * the event. False if none are found.
+     */
+    willEmitId(eventName: string, id: string): boolean;
+    /**
+     * Queues an event to be fired. This has automatic de-bouncing so that any
+     * events of the same type that occur within 100 milliseconds of a previous
+     * one will all be wrapped into a single emit rather than emitting tons of
+     * events for lots of chained inserts etc. Only the data from the last
+     * de-bounced event will be emitted.
+     * @param {String} eventName The name of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns {Emitter} The emitter instance.
+     */
+    deferEmit(eventName: string, ...data: any[]): this;
+    /**
+     * If events are cleared with the off() method while the event emitter is
+     * actively processing any events then the off() calls get added to a
+     * queue to be executed after the event emitter is finished. This stops
+     * errors that might occur by potentially modifying the event queue while
+     * the emitter is running through them. This method is called after the
+     * event emitter is finished processing.
+     * @private
+     */
+    _processRemovalQueue(): void;
+}
+export declare function makeEmitter(obj: new (...args: any[]) => any, prototypeMode: boolean): Emitter;
+export declare function makeEmitter(obj: boolean): Emitter;
+export declare function makeEmitter(obj: Record<string, unknown>, prototypeMode: boolean): Emitter;