@resolid/di 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -2,11 +2,6 @@
 type Scope = "singleton" | "transient";
 type BindingConfig = Record<string, unknown>;
 //#endregion
-//#region src/utils/index.d.ts
-type Disposable = {
-  dispose: () => Promise<void> | void;
-};
-//#endregion
 //#region src/container/index.d.ts
 type Resolve = (name: symbol) => unknown;
 type LazyResolve = <T = unknown>(name: symbol) => Readonly<{
@@ -28,6 +23,9 @@ type ToFactory = (fn: ({
   scope?: Scope;
   config?: BindingConfig;
 }) => void;
+type Disposable = {
+  dispose: () => Promise<void> | void;
+};
 type Container = {
   bind: (name: symbol) => {
     toValue: ToValue;

package/dist/index.js

@@ -1,130 +1 @@
-//#region src/utils/index.ts
-const isDisposable = (obj) => !!obj && typeof obj.dispose === "function";
-const formatChain = (chain, current) => {
-	return (current ? [...chain, current] : chain).map(String).join(" -> ");
-};
-
-//#endregion
-//#region src/container/index.ts
-const createContainer = () => {
-	const result = _createContainer();
-	return {
-		bind: result.bind,
-		resolve: result.resolve,
-		lazyResolve: result.lazyResolve,
-		dispose: result.dispose
-	};
-};
-const _createContainer = (parent, item, constructing) => {
-	const bindings = parent?.bindings ?? /* @__PURE__ */ new Map();
-	const singletons = parent?.singletons ?? /* @__PURE__ */ new Map();
-	const currentConstructing = item ? [...constructing ?? parent?.constructing ?? [], item] : [];
-	const lazyResolveQueue = [];
-	const container = {};
-	const enqueueLazyResolve = (name) => {
-		return new Promise((resolve$1) => {
-			const lazy = (value) => {
-				resolve$1(value);
-			};
-			lazyResolveQueue.push({
-				name,
-				resolve: lazy
-			});
-		});
-	};
-	const dequeueLazyResolves = async () => {
-		for (const lazyResolve$1 of lazyResolveQueue) try {
-			lazyResolve$1.resolve(await resolveBinding(lazyResolve$1.name, []));
-		} catch (e) {
-			throw new Error(`Failed to resolve lazy resolver for name ${lazyResolve$1.name.toString()}: ${e instanceof Error ? e.message : String(e)}`);
-		}
-	};
-	const bind = (name) => {
-		const toValue = (value) => {
-			bindings.set(name, {
-				factory: () => value,
-				scope: "singleton"
-			});
-		};
-		const toFunction = (fn) => {
-			bindings.set(name, {
-				factory: () => fn,
-				scope: "singleton"
-			});
-		};
-		const toFactory = (fn, options) => {
-			bindings.set(name, {
-				factory: (resolve$1, lazyResolve$1) => {
-					return fn({
-						resolver: {
-							resolve: resolve$1,
-							lazyResolve: lazyResolve$1
-						},
-						config: options?.config
-					});
-				},
-				scope: options?.scope ?? "singleton",
-				config: options?.config
-			});
-		};
-		return {
-			toValue,
-			toFunction,
-			toFactory
-		};
-	};
-	const resolveBinding = async (name, constructing$1) => {
-		const binding = bindings.get(name);
-		if (!binding) throw new Error(`No binding found for name: ${name.toString()}`);
-		const isSingleton = binding.scope === "singleton";
-		if (isSingleton && singletons.has(name)) return singletons.get(name);
-		const child = _createContainer(container, name, constructing$1);
-		const result = await binding.factory(child.resolve, child.lazyResolve);
-		if (isSingleton) singletons.set(name, result);
-		await child.dequeueLazyResolves();
-		return result;
-	};
-	const resolve = async (name) => {
-		if (currentConstructing.includes(name)) throw new Error(`Circular dependency detected: ${formatChain(currentConstructing, name)}`);
-		return resolveBinding(name);
-	};
-	const lazyResolve = (name) => {
-		let value;
-		enqueueLazyResolve(name).then((resolved) => {
-			value = resolved;
-		});
-		return { get value() {
-			if (!value) throw new Error("Lazy binding is not yet resolved. Do not use lazy-resolved bindings before the binding construction ends.");
-			return value;
-		} };
-	};
-	const dispose = async () => {
-		const disposeErrors = [];
-		for (const [name, instance] of singletons) if (isDisposable(instance)) try {
-			await instance.dispose();
-		} catch (error) {
-			disposeErrors.push({
-				name,
-				error
-			});
-		}
-		if (disposeErrors.length > 0) {
-			const errorMessages = disposeErrors.map(({ name, error }) => `${name.toString()}: ${error instanceof Error ? error.message : String(error)}`).join("; ");
-			throw new Error(`Failed to dispose ${disposeErrors.length} binding(s): ${errorMessages}`);
-		}
-	};
-	Object.assign(container, {
-		bindings,
-		singletons,
-		constructing: currentConstructing,
-		dequeueLazyResolves,
-		bind,
-		resolve,
-		lazyResolve,
-		dispose
-	});
-	return container;
-};
-
-//#endregion
-export { createContainer };
+const e=()=>{let e=new t;return{bind:t=>e.bind(t),resolve:t=>e.resolve(t),lazyResolve:t=>e.lazyResolve(t),dispose:()=>e.dispose()}};var t=class e{#bindings;#singletons;#constructing;#lazyResolveQueue=[];constructor(e,t,n){this.#bindings=e?.getBindings()??new Map,this.#singletons=e?.getSingletons()??new Map,this.#constructing=t?[...n??e?.getConstructing()??[],t]:[]}getBindings(){return this.#bindings}getSingletons(){return this.#singletons}getConstructing(){return this.#constructing}bind(e){return{toValue:t=>{this.#bindings.set(e,{factory:()=>t,scope:`singleton`})},toFunction:t=>{this.#bindings.set(e,{factory:()=>t,scope:`singleton`})},toFactory:(t,n)=>{this.#bindings.set(e,{factory:(e,r)=>t({resolver:{resolve:e,lazyResolve:r},config:n?.config}),scope:n?.scope??`singleton`,config:n?.config})}}}async#resolveBinding(t,n){let r=this.#bindings.get(t);if(!r)throw Error(`No binding found for name: ${t.toString()}`);let i=r.scope===`singleton`;if(i&&this.#singletons.has(t))return this.#singletons.get(t);let a=new e(this,t,n),o=await r.factory(e=>a.resolve(e),e=>a.lazyResolve(e));return i&&this.#singletons.set(t,o),await a.dequeueLazyResolves(),o}async dequeueLazyResolves(){for(let e of this.#lazyResolveQueue)try{e.resolve(await this.#resolveBinding(e.name,[]))}catch(t){throw Error(`Failed to resolve lazy resolver for name ${e.name.toString()}: ${t instanceof Error?t.message:String(t)}`)}}async resolve(e){if(this.#constructing.includes(e))throw Error(`Circular dependency detected: ${[...this.#constructing,e].map(String).join(` -> `)}`);return this.#resolveBinding(e)}lazyResolve(e){let t;return new Promise(t=>{this.#lazyResolveQueue.push({name:e,resolve:e=>{t(e)}})}).then(e=>{t=e}),{get value(){if(!t)throw Error(`Lazy binding is not yet resolved. Do not use lazy-resolved bindings before the binding construction ends.`);return t}}}async dispose(){let e=[];for(let[t,n]of this.#singletons)if(typeof n.dispose==`function`)try{await n.dispose()}catch(n){e.push({name:t,error:n})}if(e.length>0){let t=e.map(({name:e,error:t})=>`${e.toString()}: ${t instanceof Error?t.message:String(t)}`).join(`; `);throw Error(`Failed to dispose ${e.length} binding(s): ${t}`)}}};export{e as createContainer};

package/package.json

@@ -4,12 +4,19 @@
   "license": "MIT",
   "private": false,
   "sideEffects": false,
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The Resolid DI Container package.",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
+  "keywords": [
+    "container",
+    "ioc",
+    "inversion of control",
+    "dependency injection",
+    "di"
+  ],
   "files": [
     "dist"
   ],
@@ -21,11 +28,9 @@
   },
   "dependencies": {},
   "devDependencies": {},
-  "peerDependencies": {
-    "typescript": "^5.9.3"
-  },
+  "peerDependencies": {},
   "engines": {
-    "node": "^22.13.0 || >=24"
+    "node": "^20.19.0 || ^22.13.0 || >=24"
   },
   "homepage": "https://www.resolid.tech",
   "repository": {
@@ -37,7 +42,6 @@
     "lint": "eslint .",
     "build": "tsdown",
     "test": "vitest run",
-    "bench": "vitest bench",
     "typecheck": "tsc --noEmit"
   }
 }