emitochondria 1.2.0 → 1.2.1

package/README.md

@@ -256,35 +256,6 @@ const events = createEmitochondria<MyEvents>({
 });
 ```
 
-## ⚡ Biological API (Alternative Naming)
-
-Emitochondria offers biologically-themed aliases for all methods. Use whichever style fits your project:
-
-| Standard API | Biological Alias | Description |
-|--------------|------------------|-------------|
-| `.on()` | `.bind()` | Bind a receptor to a signal |
-| `.off()` | `.release()` | Release a receptor |
-| `.emit()` | `.pulse()` | Pulse energy through the system |
-| `.emitAsync()` | `.cascade()` | Trigger a signal cascade |
-| `.once()` | `.spike()` | Single spike of energy |
-| `.onAny()` | `.membrane()` | Membrane catches all signals |
-| `.clear()` | `.apoptosis()` | Programmed cell death |
-| `.listenerCount()` | `.receptors()` | Count of receptors |
-
-```typescript
-// Standard API
-events.on('user:login', handler);
-events.emit('user:login', data);
-
-// Biological API - same functionality, different style
-events.bind('user:login', handler);
-events.pulse('user:login', data);
-
-// Mix and match freely
-events.bind('save', async (data) => await saveToDatabase(data));
-await events.cascade('save', { id: '123' });
-```
-
 ## TypeScript Magic
 
 The type system prevents mistakes at compile time:

package/bin/emitochondria.cjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Import the compiled CLI
+require('../dist/cli/index.cjs');

package/dist/cli/index.cjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "emitochondria",
+      version: "1.2.1",
+      type: "module",
+      description: "The powerhouse of your events \u2014 A tiny, fully-typed event emitter for TypeScript with built-in error handling and memory leak detection",
+      author: "Pablo D\xEDaz A.K.A exudev",
+      license: "MIT",
+      bin: {
+        emitochondria: "./bin/emitochondria.cjs"
+      },
+      keywords: [
+        "events",
+        "emitter",
+        "event-emitter",
+        "typescript",
+        "typed",
+        "pubsub",
+        "pub-sub",
+        "subscribe",
+        "publish",
+        "error-handling",
+        "memory-leak-detection",
+        "async",
+        "type-safe"
+      ],
+      repository: {
+        type: "git",
+        url: "https://github.com/Exudev/emitochondria.git"
+      },
+      main: "./dist/index.js",
+      module: "./dist/index.mjs",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          import: {
+            types: "./dist/index.d.mts",
+            default: "./dist/index.mjs"
+          },
+          require: {
+            types: "./dist/index.d.ts",
+            default: "./dist/index.js"
+          }
+        },
+        "./schema.json": "./schema.json"
+      },
+      files: [
+        "dist",
+        "bin",
+        "schema.json"
+      ],
+      sideEffects: false,
+      scripts: {
+        build: "tsup",
+        test: "vitest",
+        "test:run": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        prepublishOnly: "npm run test:run && npm run build"
+      },
+      devDependencies: {
+        "@types/node": "^25.0.3",
+        tsup: "^8.5.1",
+        typescript: "^5.9.3",
+        vitest: "^4.0.16"
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var readline = __toESM(require("readline"), 1);
+var CONFIG_FILENAME = "emitochondria.config.json";
+var SCHEMA_URL = "https://unpkg.com/emitochondria/schema.json";
+var DEFAULT_CONFIG = {
+  $schema: SCHEMA_URL,
+  maxListeners: 10,
+  logging: {
+    timestamps: false,
+    timestampFormat: "iso",
+    timezone: "utc",
+    persist: false,
+    path: "./logs/emitochondria.log",
+    format: "text",
+    maxSize: "10MB",
+    logEvents: false,
+    logErrors: true,
+    logWarnings: true
+  }
+};
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m"
+};
+function log(icon, color, msg) {
+  console.log(`${color}${icon}${c.reset} ${msg}`);
+}
+var info = (msg) => log("\u2139", c.blue, msg);
+var success = (msg) => log("\u2713", c.green, msg);
+var warn = (msg) => log("\u26A0 ", c.yellow, msg);
+var error = (msg) => log("\u2717", c.red, msg);
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+function printHelp() {
+  console.log(`
+${c.bold}\u{1F9EC} Emitochondria CLI${c.reset}
+${c.dim}The powerhouse of your events${c.reset}
+
+${c.bold}Usage:${c.reset}
+  npx emitochondria <command>
+
+${c.bold}Commands:${c.reset}
+  init          Create emitochondria.config.json
+  init --force  Overwrite existing config file
+  help          Show this help message
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}# Create config file${c.reset}
+  npx emitochondria init
+
+  ${c.dim}# Overwrite existing config${c.reset}
+  npx emitochondria init --force
+
+${c.bold}Documentation:${c.reset}
+  https://github.com/Exudev/emitochondria
+`);
+}
+function printVersion() {
+  try {
+    const pkg = require_package();
+    console.log(`v${pkg.version}`);
+  } catch {
+    console.log("unknown");
+  }
+}
+async function initCommand(force) {
+  const configPath = path.join(process.cwd(), CONFIG_FILENAME);
+  console.log(`
+${c.bold}\u{1F9EC} Emitochondria${c.reset}
+`);
+  if (fs.existsSync(configPath)) {
+    if (!force) {
+      warn(`${CONFIG_FILENAME} already exists.`);
+      const answer = await prompt(`   Overwrite? ${c.dim}(y/N)${c.reset} `);
+      if (answer !== "y" && answer !== "yes") {
+        info("Aborted. No changes made.");
+        process.exit(0);
+      }
+    } else {
+      warn("Overwriting existing config file.");
+    }
+  }
+  try {
+    const content = JSON.stringify(DEFAULT_CONFIG, null, 2);
+    fs.writeFileSync(configPath, content + "\n", "utf8");
+    success(`Created ${c.bold}${CONFIG_FILENAME}${c.reset}`);
+    console.log(`
+${c.dim}   Location: ${configPath}${c.reset}`);
+    console.log(`
+${c.bold}Next steps:${c.reset}
+
+  1. Edit the config file to match your needs
+  2. Import and use emitochondria:
+
+     ${c.cyan}import { createEmitochondria } from 'emitochondria';${c.reset}
+
+     ${c.cyan}type MyEvents = {${c.reset}
+       ${c.cyan}'user:login': { userId: string };${c.reset}
+     ${c.cyan}};${c.reset}
+
+     ${c.cyan}const events = createEmitochondria<MyEvents>();${c.reset}
+
+${c.dim}\u{1F4D6} Docs: https://github.com/Exudev/emitochondria${c.reset}
+`);
+  } catch (err) {
+    error(`Failed to create config file: ${err}`);
+    process.exit(1);
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const flags = args.slice(1);
+  const hasForce = flags.includes("--force") || flags.includes("-f");
+  switch (command) {
+    case "init":
+      await initCommand(hasForce);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      printVersion();
+      break;
+    default:
+      error(`Unknown command: ${command}`);
+      console.log(`
+Run ${c.cyan}npx emitochondria help${c.reset} for usage.
+`);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  error(`Unexpected error: ${err}`);
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "emitochondria",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "The powerhouse of your events — A tiny, fully-typed event emitter for TypeScript with built-in error handling and memory leak detection",
   "author": "Pablo Díaz A.K.A exudev",
   "license": "MIT",
+  "bin": {
+    "emitochondria": "./bin/emitochondria.cjs"
+  },
   "keywords": [
     "events",
     "emitter",
@@ -42,6 +45,7 @@
   },
   "files": [
     "dist",
+    "bin",
     "schema.json"
   ],
   "sideEffects": false,