@resolid/di 0.6.0 → 0.7.0

package/README.md

@@ -1,17 +1,15 @@
-# Resolid: DI Container Package
+# TypeScript Dependency Injection Container
 
 ![GitHub License](https://img.shields.io/github/license/resolid/framework)
 ![NPM Version](https://img.shields.io/npm/v/%40resolid/di)
 
 <b>[Documentation](https://www.resolid.tech/docs/di)</b> | [Framework Bundle](https://github.com/resolid/framework)
 
-## TypeScript Dependency Injection Container
-
 A lightweight, fully-typed Dependency Injection (DI) container for TypeScript.
 Supports singleton & transient scopes, lazy resolution, optional dependencies, and disposable resources. Fully functional with async factories
 and avoids circular dependency issues.
 
-### Features
+## Features
 
 - Fully typed with TypeScript, no any.
 - Supports singleton and transient scopes.
@@ -19,10 +17,9 @@ and avoids circular dependency issues.
 - Optional dependency resolution.
 - Detects circular dependencies.
 - Handles disposable instances with dispose() support.
-- Fully async-compatible with inject() and injectAsync() functions.
 - Context-aware injection with InjectionContext.
 
-### Installation
+## Installation
 
 ```shell
 pnpm add @resolid/di
@@ -34,7 +31,9 @@ yarn add @resolid/di
 bun add @resolid/di
 ```
 
-### Basic Usage
+## Usage
+
+### Basic
 
 ```typescript
 import { Container, inject } from "@resolid/di";
@@ -95,65 +94,13 @@ container.add({
 });
 ```
 
-### Asynchronous Dependencies
-
-```typescript
-import { Container, injectAsync } from "@resolid/di";
-
-class AsyncDatabaseService {
-  async connect(): Promise<void> {
-    await new Promise(resolve => setTimeout(resolve, 100));
-    console.log("Database connected");
-  }
-}
-
-class AsyncUserService {
-  private db : AsyncDatabaseService
-
-  constructor(db: AsyncDatabaseService) {
-    this.db = db;
-  }
-
-  async getUser(id: number): Promise<string> {
-    return `User ${id}`;
-  }
-}
-
-const container = new Container();
-
-container.add({
-  token: AsyncDatabaseService,
-  factory: async () => {
-    const db = new AsyncDatabaseService();
-    await db.connect();
-    return db;
-  },
-  async: true,
-});
-
-container.add({
-  token: AsyncUserService,
-  factory: async () => {
-    const db = await injectAsync(AsyncDatabaseService);
-    return new AsyncUserService(db)
-  },
-  async: true,
-});
-
-// Resolve async services
-const userService = await container.getAsync(AsyncUserService);
-const user = await userService.getUser(1);
-
-console.log(user); // Output: User 1
-```
-
 ### Optional Dependencies
 
 ```typescript
 import { Container, inject } from "@resolid/di";
 
 class AnalyticsService {
-  private logger?: LogService
+  private logger?: LogService;
 
   constructor(logger?: LogService) {
     this.logger = logger;
@@ -186,7 +133,7 @@ analytics.track("page_view"); // Output: Analytics (no logger): page_view
 import { Container, inject } from "@resolid/di";
 
 class ReportService {
-  private getLogger : () => LogService;
+  private getLogger: () => LogService;
 
   constructor(private getLogger: () => LogService) {
     this.getLogger = getLogger;
@@ -255,11 +202,10 @@ const container = new Container();
 
 container.add({
   token: DatabaseConnection,
-  factory: async () => new DatabaseConnection(),
-  async: true,
+  factory: () => new DatabaseConnection(),
 });
 
-const db = await container.getAsync(DatabaseConnection);
+const db = container.get(DatabaseConnection);
 
 // Dispose all singleton instances
 await container.dispose(); // Output: Database connection closed

package/dist/index.d.mts

@@ -0,0 +1,71 @@
+//#region src/shared/index.d.ts
+type Token<T = unknown> = symbol | (new (...args: any[]) => T) | {
+  prototype: T;
+  name: string;
+};
+interface Disposable {
+  dispose: () => Promise<void> | void;
+}
+interface Resolver {
+  get: (<T>(token: Token<T>) => T) & (<T>(token: Token<T>, options: {
+    optional: true;
+  }) => T | undefined) & (<T>(token: Token<T>, options: {
+    lazy: true;
+  }) => () => T) & (<T>(token: Token<T>, options: {
+    lazy: true;
+    optional: true;
+  }) => () => T | undefined) & (<T>(token: Token<T>, options: {
+    lazy?: false;
+    optional?: boolean;
+  }) => T | undefined) & (<T>(token: Token<T>, options?: {
+    lazy?: boolean;
+    optional?: boolean;
+  }) => T | undefined | (() => T | undefined));
+}
+//#endregion
+//#region src/container/index.d.ts
+type Scope = "singleton" | "transient";
+type Provider<T = unknown> = {
+  token: Token<T>;
+  factory: () => T;
+  scope?: Scope;
+};
+declare class Container implements Resolver, Disposable {
+  private readonly _providers;
+  private readonly _singletons;
+  private readonly _constructing;
+  private _checkCircularDependency;
+  private _resolve;
+  add(provider: Provider): void;
+  get<T>(token: Token<T>): T;
+  get<T>(token: Token<T>, options: {
+    optional: true;
+  }): T | undefined;
+  get<T>(token: Token<T>, options: {
+    lazy: true;
+  }): () => T;
+  get<T>(token: Token<T>, options: {
+    lazy: true;
+    optional: true;
+  }): () => T | undefined;
+  get<T>(token: Token<T>, options: {
+    lazy?: false;
+    optional?: boolean;
+  }): T | undefined;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/inject/index.d.ts
+declare function inject<T>(token: Token<T>): T;
+declare function inject<T>(token: Token<T>, options: {
+  optional: true;
+}): T | undefined;
+declare function inject<T>(token: Token<T>, options: {
+  lazy: true;
+}): () => T;
+declare function inject<T>(token: Token<T>, options: {
+  lazy: true;
+  optional: true;
+}): () => T | undefined;
+//#endregion
+export { Container, Provider, Scope, type Token, inject };

package/dist/index.mjs

@@ -0,0 +1 @@
+var e=class extends Error{constructor(){super(`inject() must be called within a injection context`)}},t=class t{static contextStack=[];resolver;constructor(e){this.resolver=e}static current(){let t=this.contextStack[this.contextStack.length-1];if(t===void 0)throw new e;return t}run(e){t.contextStack.push(this);try{return e(this.resolver)}finally{t.contextStack.pop()}}};function n(e){return typeof e==`symbol`?e.description??String(e):e.name}var r=class{_providers=new Map;_singletons=new Map;_constructing=[];_checkCircularDependency(e){if(this._constructing.includes(e))throw Error(`Circular dependency detected ${[...this._constructing,e].map(n).join(` -> `)}`)}_resolve(e,r){this._checkCircularDependency(e);let i=this._providers.get(e);if(i===void 0){if(!r)throw Error(`No provider found for ${n(e)}`);return}let a=i.scope!==`transient`;if(a&&this._singletons.has(e))return this._singletons.get(e);this._constructing.push(e);try{let n=new t(this).run(()=>i.factory());return a&&this._singletons.set(e,n),n}finally{this._constructing.pop()}}add(e){this._providers.set(e.token,e)}get(e,t){return t?.lazy??!1?()=>this.get(e,{...t,lazy:!1}):this._resolve(e,t?.optional??!1)}async dispose(){let e=0,t=``;for(let[r,i]of this._singletons)if(typeof i.dispose==`function`)try{await i.dispose()}catch(i){e++,t+=`${n(r)}: ${i instanceof Error?i.message:i}; `}if(this._singletons.clear(),e>0)throw Error(`Failed to dispose ${e} provider(s):\n${t.slice(0,-2)}`)}};function i(n,r){try{return t.current().run(e=>e.get(n,r))}catch(t){if(t instanceof e&&r?.optional==1)return;throw t}}export{r as Container,i as inject};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@resolid/di",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": false,
-  "description": "The Resolid DI Container package.",
+  "description": "TypeScript Dependency Injection Container",
   "keywords": [
     "resolid",
     "container",
@@ -26,20 +26,18 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.3",
-    "tsdown": "^0.15.10",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.3"
+    "tsdown": "^0.16.8",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"

package/dist/index.d.ts

@@ -1,119 +0,0 @@
-//#region src/shared/index.d.ts
-type Class<T> = new (...args: any[]) => T;
-type Token<T = unknown> = symbol | Class<T>;
-interface Disposable {
-  dispose: () => Promise<void> | void;
-}
-interface Resolver {
-  get: (<T>(token: Token<T>) => T) & (<T>(token: Token<T>, options: {
-    optional: true;
-  }) => T | undefined) & (<T>(token: Token<T>, options: {
-    lazy: true;
-  }) => () => T) & (<T>(token: Token<T>, options: {
-    lazy: true;
-    optional: true;
-  }) => () => T | undefined) & (<T>(token: Token<T>, options: {
-    lazy?: false;
-    optional?: boolean;
-  }) => T | undefined) & (<T>(token: Token<T>, options?: {
-    lazy?: boolean;
-    optional?: boolean;
-  }) => T | undefined | (() => T | undefined));
-  getAsync: (<T>(token: Token<T>) => Promise<T>) & (<T>(token: Token<T>, options: {
-    optional: true;
-  }) => Promise<T | undefined>) & (<T>(token: Token<T>, options: {
-    lazy: true;
-  }) => () => Promise<T>) & (<T>(token: Token<T>, options: {
-    lazy: true;
-    optional: true;
-  }) => () => Promise<T | undefined>) & (<T>(token: Token<T>, options: {
-    lazy?: false;
-    optional?: boolean;
-  }) => Promise<T | undefined>) & (<T>(token: Token<T>, options?: {
-    lazy?: boolean;
-    optional?: boolean;
-  }) => Promise<T | undefined> | (() => Promise<T | undefined>));
-}
-//#endregion
-//#region src/container/index.d.ts
-type Scope = "singleton" | "transient";
-type SyncProvider<T = unknown> = {
-  token: Token<T>;
-  factory: (resolver: Resolver) => T;
-  async?: false;
-  scope?: Scope;
-};
-type AsyncProvider<T = unknown> = {
-  token: Token<T>;
-  factory: (resolver: Resolver) => Promise<T>;
-  async?: true;
-  scope?: Scope;
-};
-type Provider<T = unknown> = SyncProvider<T> | AsyncProvider<T>;
-declare class Container implements Resolver, Disposable {
-  private readonly _providers;
-  private readonly _singletons;
-  private readonly _constructing;
-  private _checkCircularDependency;
-  private _resolveProvide;
-  private _resolve;
-  private _resolveAsync;
-  add(provider: Provider): void;
-  get<T>(token: Token<T>): T;
-  get<T>(token: Token<T>, options: {
-    optional: true;
-  }): T | undefined;
-  get<T>(token: Token<T>, options: {
-    lazy: true;
-  }): () => T;
-  get<T>(token: Token<T>, options: {
-    lazy: true;
-    optional: true;
-  }): () => T | undefined;
-  get<T>(token: Token<T>, options: {
-    lazy?: false;
-    optional?: boolean;
-  }): T | undefined;
-  getAsync<T>(token: Token<T>): Promise<T>;
-  getAsync<T>(token: Token<T>, options: {
-    optional: true;
-  }): Promise<T | undefined>;
-  getAsync<T>(token: Token<T>, options: {
-    lazy: true;
-  }): () => Promise<T>;
-  getAsync<T>(token: Token<T>, options: {
-    lazy: true;
-    optional: true;
-  }): () => Promise<T | undefined>;
-  getAsync<T>(token: Token<T>, options: {
-    lazy?: false;
-    optional?: boolean;
-  }): Promise<T | undefined>;
-  dispose(): Promise<void>;
-}
-//#endregion
-//#region src/inject/index.d.ts
-declare function inject<T>(token: Token<T>): T;
-declare function inject<T>(token: Token<T>, options: {
-  optional: true;
-}): T | undefined;
-declare function inject<T>(token: Token<T>, options: {
-  lazy: true;
-}): () => T;
-declare function inject<T>(token: Token<T>, options: {
-  lazy: true;
-  optional: true;
-}): () => T | undefined;
-declare function injectAsync<T>(token: Token<T>): Promise<T>;
-declare function injectAsync<T>(token: Token<T>, options: {
-  optional: true;
-}): Promise<T | undefined>;
-declare function injectAsync<T>(token: Token<T>, options: {
-  lazy: true;
-}): () => Promise<T>;
-declare function injectAsync<T>(token: Token<T>, options: {
-  lazy: true;
-  optional: true;
-}): () => Promise<T | undefined>;
-//#endregion
-export { Container, Provider, type Resolver, Scope, type Token, inject, injectAsync };

package/dist/index.js

@@ -1 +0,0 @@
-var e=class extends Error{constructor(){super(`inject() / injectAsync() must be called within a injection context`)}},t=class t{static contextStack=[];resolver;constructor(e){this.resolver=e}static current(){let t=this.contextStack[this.contextStack.length-1];if(t===void 0)throw new e;return t}run(e){t.contextStack.push(this);try{return e(this.resolver)}finally{t.contextStack.pop()}}async runAsync(e){t.contextStack.push(this);try{return await e(this.resolver)}finally{t.contextStack.pop()}}};function n(e){return typeof e==`symbol`?e.description??String(e):e.name}var r=class{_providers=new Map;_singletons=new Map;_constructing=[];_checkCircularDependency(e){if(this._constructing.includes(e))throw Error(`Circular dependency detected ${[...this._constructing,e].map(n).join(` -> `)}`)}_resolveProvide(e,t){let r=this._providers.get(e);if(r===void 0&&!t)throw Error(`No provider found for ${n(e)}`);return r}_resolve(e,r){this._checkCircularDependency(e);let i=this._resolveProvide(e,r);if(i===void 0)return;if(i.async)throw Error(`Provider for ${n(e)} is async, please use injectAsync()`);let a=i.scope!==`transient`;if(a&&this._singletons.has(e))return this._singletons.get(e);this._constructing.push(e);try{let n=new t(this).run(()=>i.factory(this));return a&&this._singletons.set(e,n),n}finally{this._constructing.pop()}}async _resolveAsync(e,n){this._checkCircularDependency(e);let r=this._resolveProvide(e,n);if(r===void 0)return;let i=r.scope!==`transient`;if(i&&this._singletons.has(e))return this._singletons.get(e);this._constructing.push(e);try{let n=await new t(this).runAsync(async()=>await r.factory(this));return i&&this._singletons.set(e,n),n}finally{this._constructing.pop()}}add(e){this._providers.set(e.token,e)}get(e,t){return t?.lazy??!1?()=>this.get(e,{...t,lazy:!1}):this._resolve(e,t?.optional??!1)}getAsync(e,t){return t?.lazy??!1?()=>this.getAsync(e,{...t,lazy:!1}):this._resolveAsync(e,t?.optional??!1)}async dispose(){let e=0,t=``;for(let[r,i]of this._singletons)if(typeof i.dispose==`function`)try{await i.dispose()}catch(i){e++,t+=`${n(r)}: ${i instanceof Error?i.message:i}; `}if(this._singletons.clear(),e>0)throw Error(`Failed to dispose ${e} provider(s):\n${t.slice(0,-2)}`)}};function i(n,r){try{return t.current().run(e=>e.get(n,r))}catch(t){if(t instanceof e&&r?.optional==1)return;throw t}}function a(n,r){try{return r?.lazy?t.current().run(e=>e.getAsync(n,{...r,lazy:!0})):t.current().runAsync(e=>e.getAsync(n,{...r,lazy:!1}))}catch(t){return t instanceof e&&r?.optional===!0?r?.lazy?()=>Promise.resolve(void 0):Promise.resolve(void 0):Promise.reject(t)}}export{r as Container,i as inject,a as injectAsync};