@illuma/core 1.5.0 → 1.5.2

package/README.md

@@ -1,35 +1,37 @@
-# 🔥 **Illuma** – Angular-style Dependency Injection for TypeScript
+# **Illuma** – Dependency Injection for TypeScript
 
 ![NPM Version](https://img.shields.io/npm/v/%40illuma%2Fcore)
 ![NPM Downloads](https://img.shields.io/npm/dw/%40illuma%2Fcore)
 ![npm bundle size](https://img.shields.io/bundlephobia/min/%40illuma%2Fcore)
 ![Test coverage](./badges/coverage.svg)
 
-A lightweight, type-safe dependency injection container for TypeScript. Zero dependencies.
+A universal, lightweight and type-safe dependency injection container for TypeScript.
+Heavily inspired by Angular's DI system, but designed to work in any environment (Node.js, Bun, Deno, browsers, and more).
 
-## ✨ Features
+## Features
 
-- 🎯 **Type-Safe** – Full TypeScript support with excellent type inference
-- 🪶 **Lightweight** – Zero dependencies, minimal bundle size
-- 🔄 **Flexible** – Classes, factories, values, and aliases
-- 🎨 **Optional decorators** – Angular-style `@NodeInjectable()` decorator
-- 🔗 **Multi-Tokens** – Built-in multi-provider support
-- 🔌 **Plugin System** – Extensible architecture with custom middlewares, scanners, and diagnostics
-- 🧪 **Testkit** – Utilities for easy unit testing and mocking
-- 🌍 **Universal** – Node.js, Deno, browser, and Electron
-## 📦 Installation
+- **Type-Safe** – Excellent type inference
+- **Lightweight** – Zero dependencies, minimal bundle size
+- **Flexible** – Classes, factories, values, and aliases
+- **Optional decorators** – Injectable classes with `@NodeInjectable()` decorator
+- **Multi-Tokens** – Built-in multi-provider support
+- **Plugin System** – Extensible architecture with custom middlewares, scanners, and diagnostics
+- **TestKit** – Unit testing and mocking utilities for any testing framework
+- **Universal** – Node.js, Bun, Deno, browser, and Electron
+
+## Installation
 
 ```bash
 npm install @illuma/core
 ```
 
-## 🤝 Compatibility
+## Compatibility
 
-Anything that supports ES2015+ (ES6+).
-Practically the library is compatible with Node.js (v14+) and all modern browsers.
-For older environments, consider using a transpiler like Babel or TypeScript or provide polyfills as needed.
+Compatible with virtually anything supporting ES2015+ (ES6+).
+Practically the library is compatible with Node.js (v14+), Bun, Deno and all modern browsers.
+For older environments, consider using a transpiler or provide polyfills as needed.
 
-## 🚀 Quick Start
+## Quick start
 
 ```typescript
 import { NodeContainer, NodeInjectable, nodeInject } from '@illuma/core';
@@ -58,9 +60,11 @@ container.bootstrap();
 const userService = container.get(UserService);
 ```
 
-> **Note:** Requires `experimentalDecorators` and `emitDecoratorMetadata` in tsconfig. See [Getting Started](./docs/GETTING_STARTED.md) for decorator-free alternatives.
+> **Note:** 
+> Example above requires `experimentalDecorators` and `emitDecoratorMetadata` in tsconfig. 
+> See [Getting Started](./docs/GETTING_STARTED.md) for decorator-free alternatives.
 
-## 🏷️ Using Tokens
+## Using Tokens
 
 ```typescript
 import { NodeToken, MultiNodeToken, NodeContainer } from '@illuma/core';
@@ -95,7 +99,7 @@ const plugins = container.get(PLUGINS);  // Plugin[]: [AnalyticsPlugin, LoggingP
 
 See [Tokens Guide](./docs/TOKENS.md) for more details.
 
-## 🎨 Provider Types
+## Provider types
 
 ```typescript
 // Class provider
@@ -106,6 +110,7 @@ container.provide({ provide: CONFIG, value: { apiUrl: '...' } });
 
 // Factory provider
 container.provide({ provide: DATABASE, factory: () => {
+  // You can use nodeInject inside factories!
   const env = nodeInject(ENV);
   return createDatabase(env.connectionString);
 } });
@@ -119,7 +124,7 @@ container.provide({ provide: Database, alias: ExistingDatabase });
 
 See [Providers Guide](./docs/PROVIDERS.md) for details.
 
-## 🧪 Testing
+## Testing
 
 ```typescript
 import { createTestFactory } from '@illuma/core/testkit';
@@ -135,36 +140,43 @@ it('should fetch user', () => {
 });
 ```
 
-See [Testing Guide](./docs/TESTKIT.md) for comprehensive examples.
+See [Testing Guide](./docs/TESTKIT.md) for examples.
 
-## 📚 Documentation
+## Documentation
 
 | Guide                                              | Description                                           |
-| -------------------------------------------------- | ----------------------------------------------------- |
+| :--                                                | :--                                                   |
 | [Getting Started](./docs/GETTING_STARTED.md)       | Installation, setup, and basic usage                  |
 | [Providers](./docs/PROVIDERS.md)                   | Value, factory, class, and alias providers            |
 | [Tokens](./docs/TOKENS.md)                         | NodeToken and MultiNodeToken                          |
 | [Async Injection](./docs/ASYNC_INJECTION.md)       | Lazy loading and sub-containers                       |
-| [Testing](./docs/TESTKIT.md)                       | Testkit and mocking                                   |
+| [Testing](./docs/TESTKIT.md)                       | TestKit and mocking                                   |
 | [Plugins](./docs/PLUGINS.md)                       | Extending Illuma with custom scanners and diagnostics |
 | [Technical Overview](./docs/TECHNICAL_OVERVIEW.md) | Deep dive into how Illuma works                       |
 | [API Reference](./docs/API.md)                     | Complete API documentation                            |
 | [Troubleshooting](./docs/TROUBLESHOOTING.md)       | Error codes and solutions                             |
 
-## 🔌 Plugins
+## Plugins
 
-Illuma supports a plugin system for extending functionality. Check out these plugins:
+Illuma supports plugins! Check these out:
 
 - **[@illuma/reflect](https://github.com/git-illuma/reflect)** – Constructor metadata and property decorator injection support
 
 See [Plugins Guide](./docs/PLUGINS.md) for creating your own plugins.
 
-## 📄 License
+## Contributing
+
+Thank you for considering contributing to Illuma! I deeply appreciate your interest in making this project better.
+
+Anyways, to get you started, please take a look at the [Contributing Guide](./CONTRIBUTING.md) for guidelines on how to setup development environment, run tests, and submit pull requests.
+
+## License
 
-MIT © [bebrasmell](https://github.com/bebrasmell)
+MIT
 
-## 🔗 Links
+Created by [bebrasmell](https://github.com/bebrasmell)
 
+## Links
+- [NPM](https://npmjs.com/package/@illuma/core)
 - [GitHub](https://github.com/git-illuma/core)
-- [NPM](https://www.npmjs.com/package/@illuma/core)
 - [Issues](https://github.com/git-illuma/core/issues)

package/dist/index.cjs

@@ -377,7 +377,7 @@ __name(isNotFoundError, "isNotFoundError");
 
 // src/lib/api/decorator.ts
 var tokenRegistry = /* @__PURE__ */ new WeakMap();
-var INJECTION_SYMBOL = Symbol("Injectable");
+var INJECTION_SYMBOL = /* @__PURE__ */ Symbol("Injectable");
 function NodeInjectable() {
   return (ctor) => {
     const nodeToken = new NodeToken(`_${ctor.name}`, {
@@ -521,6 +521,17 @@ __name(nodeInject, "nodeInject");
 // src/lib/container/container.ts
 init_plugin_container();
 
+// src/lib/plugins/middlewares/runner.ts
+function runMiddlewares(middlewares, params) {
+  const ms = middlewares;
+  const next = /* @__PURE__ */ __name((i, current) => {
+    if (i >= ms.length) return current.factory();
+    return ms[i](current, (nextParams) => next(i + 1, nextParams));
+  }, "next");
+  return next(0, params);
+}
+__name(runMiddlewares, "runMiddlewares");
+
 // src/lib/provider/extractor.ts
 function extractProvider(provider) {
   if ("value" in provider) return () => provider.value;
@@ -626,24 +637,15 @@ var InjectorImpl = class {
 var Injector = new NodeToken("Injector");
 
 // src/lib/provider/tree-node.ts
-function runMiddlewares(middlewares, params) {
-  const ms = middlewares;
-  const next = /* @__PURE__ */ __name((i, current) => {
-    if (i >= ms.length) return current.factory();
-    return ms[i](current, (nextParams) => next(i + 1, nextParams));
-  }, "next");
-  return next(0, params);
-}
-__name(runMiddlewares, "runMiddlewares");
 function retrieverFactory(node, deps, transparentDeps) {
   return (token, optional) => {
     const depNode = deps.get(token);
     if (!depNode && !optional) {
-      const transparent = Array.from(transparentDeps).find((n) => "proto" in n && n.proto.parent.token === token);
+      const transparent = transparentDeps.get(token);
       if (transparent) return transparent.instance;
       throw InjectionError.untracked(token, node);
     }
-    return depNode?.instance ?? null;
+    return depNode ? depNode.instance : null;
   };
 }
 __name(retrieverFactory, "retrieverFactory");
@@ -654,7 +656,7 @@ var TreeRootNode = class {
   instant;
   middlewares;
   _deps = /* @__PURE__ */ new Set();
-  _treePool = /* @__PURE__ */ new WeakMap();
+  _treePool = /* @__PURE__ */ new Map();
   constructor(instant = true, middlewares = []) {
     this.instant = instant;
     this.middlewares = middlewares;
@@ -719,7 +721,11 @@ var TreeNodeSingle = class {
     if (this._resolved) return;
     for (const node of this._deps.values()) node.instantiate(pool, middlewares);
     for (const dep of this._transparent) dep.instantiate(pool, middlewares);
-    const retriever = retrieverFactory(this.proto.token, this._deps, this._transparent);
+    const transparentMap = /* @__PURE__ */ new Map();
+    for (const tNode of this._transparent) {
+      transparentMap.set(tNode.proto.parent.token, tNode);
+    }
+    const retriever = retrieverFactory(this.proto.token, this._deps, transparentMap);
     const factory = this.proto.factory ?? this.proto.token.opts?.factory;
     if (!factory) throw InjectionError.notFound(this.proto.token);
     const contextFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(factory, retriever), "contextFactory");
@@ -768,7 +774,11 @@ var TreeNodeTransparent = class _TreeNodeTransparent {
     if (this._resolved) return;
     for (const dep of this._transparent) dep.instantiate(pool, middlewares);
     for (const node of this._deps.values()) node.instantiate(pool, middlewares);
-    const retriever = retrieverFactory(this.proto.parent.token, this._deps, this._transparent);
+    const transparentMap = /* @__PURE__ */ new Map();
+    for (const tNode of this._transparent) {
+      transparentMap.set(tNode.proto.parent.token, tNode);
+    }
+    const retriever = retrieverFactory(this.proto.parent.token, this._deps, transparentMap);
     const refFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(this.proto.factory, retriever), "refFactory");
     this._instance = runMiddlewares(middlewares, {
       token: this.proto.parent.token,
@@ -1301,12 +1311,33 @@ var NodeContainer = class extends Illuma {
     if (isConstructor(fn) && !isInjectable(fn)) {
       throw InjectionError.invalidCtor(fn);
     }
-    const factory = isInjectable(fn) ? () => new fn() : fn;
-    return InjectionContext.instantiate(factory, (t, optional) => {
-      if (!this._rootNode) throw InjectionError.notBootstrapped();
-      const node = this._rootNode.find(t);
-      if (!node && !optional) throw InjectionError.notFound(t);
+    let factory;
+    if (isInjectable(fn)) {
+      const f = getInjectableToken(fn).opts?.factory;
+      if (!f) factory = /* @__PURE__ */ __name(() => new fn(), "factory");
+      else factory = /* @__PURE__ */ __name(() => getInjectableToken(fn).opts?.factory?.(), "factory");
+    } else {
+      factory = fn;
+    }
+    const rootNode = this._rootNode;
+    if (!rootNode) throw InjectionError.notBootstrapped();
+    const retriever = /* @__PURE__ */ __name((token, optional) => {
+      const node = rootNode.find(token);
+      if (!node && !optional) throw InjectionError.notFound(token);
       return node ? node.instance : null;
+    }, "retriever");
+    const deps = InjectionContext.scan(factory);
+    const middlewares = [
+      ...Illuma._middlewares,
+      ...this.collectMiddlewares()
+    ];
+    const contextFactory = /* @__PURE__ */ __name(() => InjectionContext.instantiate(factory, retriever), "contextFactory");
+    return runMiddlewares(middlewares, {
+      token: new NodeToken("ProducedNode"),
+      deps: new Set([
+        ...deps.values()
+      ].map((d) => d.token)),
+      factory: contextFactory
     });
   }
 };