events-ex 2.3.0 → 2.4.0

package/lib/pipe.mjs

@@ -0,0 +1,53 @@
+import defineProperty from 'util-ex/lib/defineProperty'
+
+import {methods} from './wrap-event-emitter.mjs'
+import arrRemove from './util/array-remove.mjs'
+import validObject from './util/valid-object.mjs'
+
+const hasOwnProperty = Object.prototype.hasOwnProperty
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const arrFrom        = Array.from
+const emit           = methods.emit
+
+/**
+ * Creates a pipeline between two event emitters, so that any events emitted by the first emitter are also emitted by the second emitter.
+ *
+ * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter.
+ * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter.
+ * @param {string} [name='emit'] - The name of the event to pipe (defaults to 'emit').
+ * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
+ * @throws {TypeError} - If either of the arguments is not an event emitter object.
+ */
+export function pipe(e1, e2/* , name */) {
+	let pipes
+
+	(validObject(e1) && validObject(e2))
+	let name = arguments[2]
+	if (name === undefined) {name = 'emit'}
+
+	const result = {
+		close() { arrRemove.call(pipes, e2) }
+	};
+	if (hasOwnProperty.call(e1, '__eePipes__')) {
+		(pipes = e1.__eePipes__).push(e2)
+		return result
+	}
+	defineProperty(e1, '__eePipes__', pipes = [e2])
+	let desc = getOwnPropertyDescriptor(e1, name)
+	if (!desc) {
+		desc = {}
+	} else {
+		delete desc.get
+		delete desc.set
+	}
+	desc.value = function () {
+		const data = arrFrom(pipes)
+		emit.apply(this, arguments)
+		let emitter
+		for (let i = 0; (emitter = data[i]); ++i) emit.apply(emitter, arguments)
+	}
+	defineProperty(e1, name, desc.value, desc)
+	return result
+};
+
+export default pipe

package/lib/unify.js

@@ -8,7 +8,7 @@ exports.unify = unify;
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
 var _objectForEach = _interopRequireDefault(require("./util/object-for-each"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const push = Array.prototype.apply;
+const push = Array.prototype.push;
 const defineProperty = Object.defineProperty;
 const create = Object.create;
 const hasOwnProperty = Object.prototype.hasOwnProperty;

package/lib/unify.mjs

@@ -0,0 +1,58 @@
+import validObject from './util/valid-object.mjs'
+import forEach from './util/object-for-each.mjs'
+
+const push = Array.prototype.push
+const defineProperty = Object.defineProperty
+const create = Object.create
+const hasOwnProperty = Object.prototype.hasOwnProperty
+const d = { configurable: true, enumerable: false, writable: true }
+
+/**
+ * Unifies the event listeners of two event emitter objects so that they share the same set of listeners for each event.
+ *
+ * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter object.
+ * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter object.
+ * @throws {TypeError} - If either of the arguments is not an event emitter object.
+ */
+export function unify(e1, e2) {
+	(validObject(e1) && validObject(e2))
+	if (!hasOwnProperty.call(e1, '_events')) {
+		if (!hasOwnProperty.call(e2, '_events')) {
+			d.value = create(null);
+			defineProperty(e1, '_events', d)
+			defineProperty(e2, '_events', d)
+			d.value = null
+			return
+		}
+		d.value = e2._events
+		defineProperty(e1, '_events', d)
+		d.value = null
+		return
+	}
+	const data = d.value = e1._events;
+	if (!hasOwnProperty.call(e2, '_events')) {
+		defineProperty(e2, '_events', d)
+		d.value = null
+		return
+	}
+	if (data === e2._events) {return}
+	forEach(e2._events, function (listener, name) {
+		if (!data[name]) {
+			data[name] = listener
+			return
+		}
+		if (typeof data[name] === 'object') {
+			if (typeof listener === 'object') {push.apply(data[name], listener)}
+			else data[name].push(listener)
+		} else if (typeof listener === 'object') {
+			listener.unshift(data[name])
+			data[name] = listener
+		} else {
+			data[name] = [data[name], listener]
+		}
+	});
+	defineProperty(e2, '_events', d)
+	d.value = null
+}
+
+export default unify

package/lib/util/array-remove.mjs

@@ -0,0 +1,16 @@
+const indexOf = Array.prototype.indexOf
+const forEach = Array.prototype.forEach
+const splice  = Array.prototype.splice
+
+export function remove(/* ...itemsToRemove */) {
+	forEach.call(
+		arguments,
+		function (item) {
+			const index = indexOf.call(this, item)
+			if (index !== -1) {splice.call(this, index, 1)}
+		},
+		this
+	)
+}
+
+export default remove

package/lib/util/object-for-each.mjs

@@ -0,0 +1,20 @@
+import value from './valid-object.mjs'
+
+const bind                    = Function.prototype.bind
+const keys                    = Object.keys
+
+export function forEach(obj, cb /* , thisArg, compareFn */) {
+  const thisArg = arguments[2]
+  const compareFn = arguments[3]
+  obj = Object(value(obj))
+
+  const list = keys(obj)
+  if (compareFn) {
+    list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : undefined)
+  }
+  return list.forEach(function (key, index) {
+    return cb.call(thisArg, obj[key], key, obj, index)
+  });
+}
+
+export default forEach

package/lib/util/promise-any.mjs

@@ -0,0 +1,45 @@
+/**
+ * Simple polyfill for AggregateError if it doesn't exist.
+ */
+const _AggregateError = typeof AggregateError !== 'undefined'
+  ? AggregateError
+  : function AggregateError(errors, message) {
+    const error = new Error(message);
+    error.name = 'AggregateError';
+    error.errors = errors;
+    return error;
+  };
+
+/**
+ * Ensures Promise.any exists, or provides a polyfill.
+ */
+if (typeof Promise.any !== 'function') {
+  Promise.any = function (promises) {
+    return new Promise((resolve, reject) => {
+      promises = Array.from(promises);
+      const len = promises.length;
+      let errors = [];
+      let rejectedCount = 0;
+
+      if (len === 0) {
+        return reject(new _AggregateError(errors, 'All promises were rejected'));
+      }
+
+      promises.forEach((promise, index) => {
+        Promise.resolve(promise)
+          .then((value) => {
+            resolve(value);
+          })
+          .catch((error) => {
+            errors[index] = error;
+            rejectedCount++;
+            if (rejectedCount === len) {
+              reject(new _AggregateError(errors, 'All promises were rejected'));
+            }
+          });
+      });
+    });
+  };
+}
+
+export default Promise.any;

package/lib/util/string-pad.mjs

@@ -0,0 +1,19 @@
+import toInteger from "./to-int.mjs"
+import value from "./valid-object.mjs"
+
+const repeat 		= String.prototype.repeat
+const abs       = Math.abs
+const max       = Math.max
+
+export function pad(fill /* , length */) {
+	const self = String(value(this))
+  const sLength = self.length
+  let length = arguments[1]
+
+	length = isNaN(length) ? 1 : toInteger(length)
+	fill = repeat.call(String(fill), abs(length))
+	if (length >= 0) {return fill.slice(0, max(0, length - sLength)) + self}
+	return self + (sLength + length >= 0 ? "" : fill.slice(length + sLength))
+}
+
+export default pad

package/lib/util/to-int.mjs

@@ -0,0 +1,9 @@
+const round = Math.round
+export function toInt(value) {
+  if (isNaN(value)) {return 0}
+  value = Number(value)
+  if (value === 0 || !isFinite(value)) {return value}
+  return round(value)
+}
+
+export default toInt

package/lib/util/valid-callable.mjs

@@ -0,0 +1,6 @@
+export function validCallable(fn) {
+  if (typeof fn !== "function") {throw new TypeError(fn + " is not a function")}
+	return fn
+}
+
+export default validCallable

package/lib/util/valid-object.mjs

@@ -0,0 +1,8 @@
+import {isObject} from 'util-ex'
+
+export function validObject(value) {
+	if (!isObject(value)) {throw new TypeError(value + " is not an Object")}
+	return value
+}
+
+export default validObject

package/lib/wrap-event-emitter.d.ts

@@ -4,6 +4,6 @@
  * @param {Object} [options] optional configuration for the emitter
  * @returns o or new Event instance
  */
-export function wrapEventEmitter(o?: any, options?: any): any;
+export function wrapEventEmitter(o?: Object, options?: Object): any;
 export const methods: any;
 export default wrapEventEmitter;

package/lib/wrap-event-emitter.mjs

@@ -0,0 +1,46 @@
+import {defineProperty} from 'util-ex'
+import eventable from './eventable.mjs'
+
+const create = Object.create;
+const defineProperties = Object.defineProperties;
+
+export const methods = eventable().methods;
+
+/**
+ * Minimal set of core methods to be injected into an existing object.
+ */
+const descriptors = {
+  on: { value: methods.on },
+  once: { value: methods.once },
+  off: { value: methods.off },
+  emit: { value: methods.emit },
+  emitAsync: { value: methods.emitAsync },
+  setEmitterOptions: { value: methods.setEmitterOptions },
+};
+
+/**
+ * Full set of all available methods from eventable for standalone instances.
+ */
+const fullDescriptors = {};
+Object.keys(methods).forEach(key => {
+  fullDescriptors[key] = { value: methods[key] };
+});
+
+const base = defineProperties({}, fullDescriptors);
+
+/**
+ * Create or inject the eventable instance into the object
+ * @param {Object} [o] the optional instance to eventable
+ * @param {Object} [options] optional configuration for the emitter
+ * @returns o or new Event instance
+ */
+export function wrapEventEmitter(o, options) {
+  const result = o == null ? create(base) : defineProperties(Object(o), descriptors)
+  defineProperty(result, '_events', {})
+  if (options && options.emitterOptions) {
+    result.setEmitterOptions(options.emitterOptions)
+  }
+  return result
+};
+
+export default wrapEventEmitter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "events-ex",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Browser-friendly enhanced events most compatible with standard node.js, it's powerful eventable ability.",
   "contributors": [
     {
@@ -35,31 +35,38 @@
     "url": "git://github.com/snowyu/events-ex.js.git"
   },
   "main": "./lib/index.js",
-  "module": "./src/index.js",
+  "module": "./lib/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js"
+    }
+  },
   "dependencies": {
-    "custom-ability": "^2.1.0",
-    "util-ex": "^2.5.1"
+    "custom-ability": "^2.2.0",
+    "util-ex": "^2.7.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^7.7.0",
-    "@babel/cli": "^7.28.6",
-    "@babel/core": "^7.29.0",
-    "@babel/plugin-proposal-dynamic-import": "^7.18.6",
-    "@babel/plugin-transform-modules-commonjs": "^7.28.6",
-    "@babel/register": "^7.28.6",
-    "chai": "~4.3.10",
-    "eslint": "^10.0.3",
+    "@antfu/eslint-config": "^9.1.0",
+    "@babel/cli": "^8.0.1",
+    "@babel/core": "^8.0.1",
+    "@babel/plugin-transform-dynamic-import": "^8.0.1",
+    "@babel/plugin-transform-modules-commonjs": "^8.0.1",
+    "@babel/register": "^8.0.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "chai": "~6.2.2",
+    "eslint": "^10.4.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-tsdoc": "^0.5.2",
-    "mocha": "^11.7.5",
-    "prettier": "^3.8.1",
-    "typedoc": "^0.28.17",
-    "typedoc-plugin-markdown": "^4.10.0",
-    "typescript": "~5.7.3"
+    "prettier": "^3.9.4",
+    "typedoc": "^0.28.19",
+    "typedoc-plugin-markdown": "^4.11.0",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "npm run build.cjs && npm run build.ts && npm run doc.md",
-    "build.cjs": "babel src --out-dir lib --config-file ./.babelrc",
+    "build.cjs": "babel src --out-dir lib --config-file ./.babelrc && node scripts/copy-to-mjs.mjs",
     "build.ts": "tsc --declaration --emitDeclarationOnly --outDir lib && cp src/event-emitter.d.ts lib/",
     "clean": "rm -fr web docs lib",
     "clean.doc": "rm -fr web docs",
@@ -69,9 +76,11 @@
     "doc.md": "typedoc --plugin typedoc-plugin-markdown --out docs ./src",
     "lint": "npx eslint --config .eslintrc.yml src",
     "lint.fix": "npm run lint -- --fix",
-    "release": "npm run clean && npm run build && git add docs && git ci -m 'docs: update API docs' && npx commit-and-tag-version -s",
+    "release": "npm run clean && npm run build && git add docs -f && git ci -m 'docs: update API docs' && npx commit-and-tag-version -s",
     "release.alpha": "npm run release -- --prerelease alpha",
-    "test": "mocha"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "pre-commit": {
     "run": [

package/scripts/copy-to-mjs.mjs

@@ -0,0 +1,79 @@
+/**
+ * Copies all .js files from src/ to lib/ as .mjs files,
+ * rewriting relative import/export paths from .js to .mjs
+ * (and adding .mjs to bare relative paths missing an extension).
+ *
+ * This ensures Node.js recognizes the ESM source files natively
+ * (via .mjs extension) without needing "type": "module" in
+ * package.json.
+ */
+import fs from 'fs'
+import path from 'path'
+
+const SRC_DIR = "src";
+const LIB_DIR = "lib";
+
+// Matches:  from './foo.js'   from "../bar.js"   from './baz'
+// Does NOT match bare specifiers like: from "inherits-ex"
+const IMPORT_RE = /(from\s+['"])(\.\.?\/[^'"]*?)(\.js)?(['"])/g;
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * Recursively walk a directory and process all .js files.
+ */
+function walkDir(currentDir, relativeDir) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    const relativePath = relativeDir
+      ? path.join(relativeDir, entry.name)
+      : entry.name;
+
+    if (entry.isDirectory()) {
+      walkDir(fullPath, relativePath);
+    } else if (entry.name.endsWith(".js")) {
+      processFile(fullPath, relativePath);
+    }
+  }
+}
+
+/**
+ * Read a .js source file, rewrite import paths, and write as .mjs.
+ */
+function processFile(srcPath, relativePath) {
+  const content = fs.readFileSync(srcPath, "utf8");
+  const mjsContent = content.replace(
+    IMPORT_RE,
+    (match, prefix, modulePath, dotJs, suffix) => {
+      // prefix:  from "   or   from '
+      // modulePath:  ./foo   or   ../bar/baz
+      // dotJs:  .js  (if present)
+      // suffix:  "   or   '
+      return `${prefix}${modulePath}.mjs${suffix}`;
+    },
+  );
+
+  const mjsName = entryNameToMjs(relativePath);
+  const destPath = path.join(LIB_DIR, mjsName);
+
+  ensureDir(path.dirname(destPath));
+  fs.writeFileSync(destPath, mjsContent, "utf8");
+
+  console.log(`  ✓ ${relativePath} → ${path.join("lib", mjsName)}`);
+}
+
+function entryNameToMjs(name) {
+  return name.replace(/\.js$/, ".mjs");
+}
+
+// --- Main ---
+console.log("Copying ESM files (.mjs) from src/ to lib/ ...");
+ensureDir(LIB_DIR);
+walkDir(SRC_DIR, "");
+console.log("Done.");

package/src/consts.js

@@ -10,4 +10,14 @@ export const states = {
   ABORT,
 }
 
+/* v8 ignore next — false branch only reachable without Symbol, which is impossible in Node.js */
 export const RegExpEventSymbol = typeof Symbol === 'function' ? Symbol('RegExpEvent') : '@@RegExpEvent'
+
+/**
+ * Creates an AbortError with name 'AbortError'.
+ * Ensures a fresh Error instance each call for proper stack traces.
+ * @returns {Error}
+ */
+export function createAbortError() {
+  return Object.assign(new Error('The operation was aborted'), { name: 'AbortError' })
+}