@resolid/di 0.6.1 → 0.7.1

package/README.md

@@ -17,7 +17,6 @@ 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
@@ -95,58 +94,6 @@ 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
@@ -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.ts → index.d.mts}

@@ -21,45 +21,21 @@ interface Resolver {
     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> = {
+interface Provider<T = unknown> {
   token: Token<T>;
-  factory: (resolver: Resolver) => Promise<T>;
-  async?: true;
+  factory: () => T;
   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: {
@@ -73,24 +49,9 @@ declare class Container implements Resolver, Disposable {
     optional: true;
   }): () => T | undefined;
   get<T>(token: Token<T>, options: {
-    lazy?: false;
+    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
@@ -106,16 +67,5 @@ 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 };
+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,56 +1,53 @@
 {
   "name": "@resolid/di",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "private": false,
   "description": "TypeScript Dependency Injection Container",
   "keywords": [
-    "resolid",
     "container",
-    "ioc",
-    "inversion of control",
+    "dependency injection",
     "di",
-    "dependency injection"
+    "inversion of control",
+    "ioc",
+    "resolid"
   ],
   "homepage": "https://www.resolid.tech",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/resolid/framework.git",
-    "directory": "packages/di"
-  },
   "license": "MIT",
   "author": {
     "name": "Huijie Wei",
     "email": "hello@resolid.tech"
   },
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/resolid/framework.git",
+    "directory": "packages/di"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.4",
-    "tsdown": "^0.15.11",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.4"
-  },
-  "engines": {
-    "node": "^20.19.0 || ^22.13.0 || >=24"
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
+  "devDependencies": {
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24"
+  },
   "scripts": {
     "build": "tsdown",
-    "lint": "eslint .",
+    "lint": "oxlint",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }

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};