@enshou/di 0.0.1 → 0.1.1

package/README.md

@@ -0,0 +1,137 @@
+# @enshou/di
+
+A small dependency injection container for TypeScript.
+
+It gives you a typed token system, a simple container, and an explicit
+`@Inject(...)` decorator for constructor dependencies.
+
+## Installation
+
+```bash
+pnpm add @enshou/di
+```
+
+## Quick example
+
+```ts
+import { Container, Inject, createToken } from '@enshou/di'
+
+type AppConfig = {
+  apiUrl: string
+}
+
+const CONFIG = createToken<AppConfig>('config')
+const LOGGER = createToken<Logger>('logger')
+const API = createToken<ApiClient>('api')
+
+class Logger {
+  log(message: string) {
+    console.log(message)
+  }
+}
+
+@Inject([CONFIG, LOGGER])
+class ApiClient {
+  constructor(
+    private readonly config: AppConfig,
+    private readonly logger: Logger,
+  ) {}
+
+  ping() {
+    this.logger.log(`GET ${this.config.apiUrl}/ping`)
+  }
+}
+
+const container = new Container()
+
+container.registerValue(CONFIG, {
+  apiUrl: 'https://example.dev',
+})
+
+container.registerClass(LOGGER, Logger)
+container.registerClass(API, ApiClient)
+
+const api = container.resolve(API)
+api.ping()
+```
+
+## API
+
+### `createToken<T>(description)`
+
+Creates a unique, typed token.
+
+```ts
+const USER_REPOSITORY = createToken<UserRepository>('user-repository')
+```
+
+### `new Container()`
+
+Creates a new dependency container.
+
+### `container.registerValue(token, value)`
+
+Registers a prebuilt value.
+
+Values are stored in the singleton cache, so resolving the same token always
+returns the same instance.
+
+```ts
+container.registerValue(CONFIG, { apiUrl: 'https://example.dev' })
+```
+
+### `container.registerClass(token, Class, scope?)`
+
+Registers a class provider for a token.
+
+- `singleton` by default: the instance is created once and reused
+- `transient`: a new instance is created on every `resolve`
+
+```ts
+container.registerClass(LOGGER, Logger, 'singleton')
+container.registerClass(API, ApiClient, 'transient')
+```
+
+### `container.resolve(token)`
+
+Resolves a dependency by token.
+
+Throws if no provider has been registered for that token.
+
+```ts
+const logger = container.resolve(LOGGER)
+```
+
+### `@Inject(tokens)`
+
+Declares the constructor dependencies for a class.
+
+The order of tokens must match the order of constructor parameters.
+
+```ts
+@Inject([CONFIG, LOGGER])
+class ApiClient {
+  constructor(config: AppConfig, logger: Logger) {}
+}
+```
+
+## Container behavior
+
+- `registerValue` always stores the value in the singleton cache
+- class dependencies are resolved recursively through `resolve`
+- singleton instances are created lazily on first resolution
+- transient instances are never cached
+
+## Limitations
+
+- dependencies are declared explicitly with `@Inject(...)`; constructor types are not read automatically
+- the container only supports class providers and value providers
+- circular dependencies are not handled specially
+- tokens are compared by identity, so you must use the same token instance for registration and resolution
+
+## Exports
+
+```ts
+import { Container, Inject, createToken } from '@enshou/di'
+import type { Scope, Token } from '@enshou/di'
+```

package/dist/index.d.ts

@@ -1,4 +1,22 @@
-//#region src/index.d.ts
-declare const DI = "DI";
+//#region src/token.d.ts
+type Token<T> = symbol & {
+  __type: T;
+};
+declare function createToken<T>(description: string): Token<T>;
 //#endregion
-export { DI };
+//#region src/container.d.ts
+type Class$1<T> = new (...args: any[]) => T;
+type Scope = "singleton" | "transient";
+declare class Container {
+  private readonly providers;
+  private readonly singletonCache;
+  registerValue(token: Token<unknown>, value: unknown): void;
+  registerClass(token: Token<unknown>, value: Class$1<any>, scope?: Scope): void;
+  resolve<T>(token: Token<T>): T;
+}
+//#endregion
+//#region src/inject.d.ts
+type Class<T> = new (...args: any[]) => T;
+declare function Inject(tokens: Array<Token<any>>): <T extends Class<any>>(target: T, _context?: ClassDecoratorContext<T>) => void;
+//#endregion
+export { Container, Inject, type Scope, type Token, createToken };

package/dist/index.js

@@ -1,4 +1,41 @@
-//#region src/index.ts
-const DI = "DI";
+//#region src/metadata.ts
+const INJECTS_KEY = Symbol("injects");
 //#endregion
-export { DI };
+//#region src/container.ts
+var Container = class {
+	providers = /* @__PURE__ */ new Map();
+	singletonCache = /* @__PURE__ */ new Map();
+	registerValue(token, value) {
+		this.singletonCache.set(token, value);
+	}
+	registerClass(token, value, scope = "singleton") {
+		this.providers.set(token, {
+			kind: "class",
+			useClass: value,
+			scope
+		});
+	}
+	resolve(token) {
+		if (this.singletonCache.has(token)) return this.singletonCache.get(token);
+		const provider = this.providers.get(token);
+		if (!provider) throw Error(`No provider for ${String(token)}`);
+		const deps = (provider.useClass[INJECTS_KEY] ?? []).map(this.resolve.bind(this));
+		const value = new provider.useClass(...deps);
+		if (provider.scope === "singleton") this.singletonCache.set(token, value);
+		return value;
+	}
+};
+//#endregion
+//#region src/inject.ts
+function Inject(tokens) {
+	return function(target, _context) {
+		target[INJECTS_KEY] = tokens;
+	};
+}
+//#endregion
+//#region src/token.ts
+function createToken(description) {
+	return Symbol(description);
+}
+//#endregion
+export { Container, Inject, createToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enshou/di",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "private": false,
   "license": "Apache-2.0",
   "author": "Ivan Popov <iiivanpopov999@gmail.com>",
@@ -20,7 +20,8 @@
   },
   "devDependencies": {
     "@typescript/native-preview": "^7.0.0-dev.20260328.1",
-    "tsdown": "^0.21.7"
+    "tsdown": "^0.21.7",
+    "vitest": "^4.1.2"
   },
   "scripts": {
     "build": "tsdown"