getbox 1.4.0 → 2.0.0

package/dist/index.mjs

@@ -1,4 +1,6 @@
 //#region src/index.ts
+const cacheSymbol = Symbol("Box.cache");
+const isClass = (fn) => fn.prototype !== void 0 && Function.prototype.toString.call(fn).startsWith("class");
 /**
 * Creates a {@link Constructor} from a factory function.
 * The factory receives the box as an argument, allowing it to resolve other dependencies.
@@ -13,9 +15,11 @@
 * ```
 */
 function factory(init) {
-	return { init };
+	return {
+		[cacheSymbol]: true,
+		init
+	};
 }
-const noCacheSymbol = Symbol("Box.noCache");
 /**
 * Creates a {@link Constructor} that computes a value from the box without caching the result.
 *
@@ -25,7 +29,7 @@ const noCacheSymbol = Symbol("Box.noCache");
 *   baseUrl = "https://example.com";
 * }
 *
-* const RequestContext = derive((box) => ({
+* const RequestContext = computed((box) => ({
 *   baseUrl: box.get(Config).baseUrl,
 *   timestamp: Date.now(),
 * }));
@@ -35,21 +39,12 @@ const noCacheSymbol = Symbol("Box.noCache");
 * console.log(ctx1 === ctx2); // false
 * ```
 */
-function derive(init) {
-	return {
-		init,
-		[noCacheSymbol]: true
-	};
-}
-/**
-* @deprecated Use {@link derive} instead.
-*/
-function transient(init) {
-	return derive(init);
+function computed(init) {
+	return { init };
 }
 /**
 * Creates a {@link Constructor} that always resolves to the given constant value.
-* Constant values are never cached since they are already fixed.
+* Constant values are already fixed and do not need caching.
 *
 * @example
 * ```ts
@@ -58,19 +53,15 @@ function transient(init) {
 * ```
 */
 function constant(value) {
-	return {
-		init: () => value,
-		[noCacheSymbol]: true
-	};
+	return { init: () => value };
 }
 /**
 * Dependency injection container that resolves and caches instances from
 * a {@link Constructor}.
 *
-* A constructor is an object with an `init(box: Box)` method,
-* a class with a `static init(box: Box)` method, or a class with a
-* no-argument constructor. The {@link factory} and {@link constant} helpers
-* create constructors from functions and values respectively.
+* A constructor is a class with a `static init` function, a class with a
+* no-argument constructor, or a function-based constructor created by
+* {@link factory}, {@link computed}, or {@link constant}.
 *
 * @example
 * ```ts
@@ -92,38 +83,34 @@ function constant(value) {
 */
 var Box = class {
 	cache = /* @__PURE__ */ new Map();
-	/**
-	* Creates a new instance without caching.
-	*/
-	new(constructor) {
-		return "init" in constructor ? constructor.init(this) : new constructor();
-	}
-	/**
-	* Resolves an instance from the cache, or creates and caches a new one.
-	* Subsequent calls with the same constructor return the cached instance.
-	*/
-	get(constructor) {
-		if (this.cache.has(constructor)) return this.cache.get(constructor);
-		const value = this.new(constructor);
-		if (!(noCacheSymbol in constructor && constructor[noCacheSymbol])) this.cache.set(constructor, value);
-		return value;
+	new(arg) {
+		if (Array.isArray(arg)) return arg.map((c) => this.new(c));
+		if (typeof arg === "function") return "init" in arg ? arg.init(this) : new arg();
+		if ("init" in arg && !isClass(arg.init)) return arg.init(this);
+		const result = {};
+		for (const [key, constructor] of Object.entries(arg)) result[key] = this.new(constructor);
+		return result;
 	}
-	/** Resolves multiple constructors at once. */
-	all = new BoxAll(this);
-	/**
-	* Returns a {@link Construct} builder for creating class instances by
-	* resolving constructors for each constructor parameter.
-	*
-	* Intended to be used inside a class's `static init` method. The instance
-	* returned by the builder is never cached itself, but can be cached when
-	* the class is retrieved via {@link Box.get} or new via {@link Box.new}.
-	*/
-	for(constructor) {
-		return new Construct(this, constructor);
+	get(arg) {
+		if (Array.isArray(arg)) return arg.map((c) => this.get(c));
+		if (typeof arg === "function") {
+			if (this.cache.has(arg)) return this.cache.get(arg);
+			const value = "init" in arg ? arg.init(this) : new arg();
+			this.cache.set(arg, value);
+			return value;
+		}
+		if ("init" in arg && !isClass(arg.init)) {
+			if (this.cache.has(arg)) return this.cache.get(arg);
+			const value = arg.init(this);
+			if (cacheSymbol in arg) this.cache.set(arg, value);
+			return value;
+		}
+		const result = {};
+		for (const [key, constructor] of Object.entries(arg)) result[key] = this.get(constructor);
+		return result;
 	}
 	/**
-	* Returns a {@link StaticConstruct} builder for defining a `static init` method.
-	* The result can be assigned directly to `static init`.
+	* Returns a `static init` function builder.
 	*
 	* @example
 	* ```ts
@@ -134,7 +121,7 @@ var Box = class {
 	* ```
 	*/
 	static init(constructor) {
-		return new StaticConstruct(constructor);
+		return new StaticInit(constructor);
 	}
 	/**
 	* Registers a mock value in the box's cache for a given constructor.
@@ -146,84 +133,23 @@ var Box = class {
 	/**
 	* Removes the instance from the box's cache for a given constructor.
 	* Removes all instances if no constructor is provided.
-	*/
-	static clear(box, constructor) {
-		if (!constructor) return box.cache.clear();
-		box.cache.delete(constructor);
-	}
-};
-/** Resolves multiple constructors at once from a {@link Box}. */
-var BoxAll = class {
-	constructor(box) {
-		this.box = box;
-	}
-	new(constructors) {
-		if (Array.isArray(constructors)) return constructors.map((c) => this.box.new(c));
-		const result = {};
-		for (const [key, constructor] of Object.entries(constructors)) result[key] = this.box.new(constructor);
-		return result;
-	}
-	get(constructors) {
-		if (Array.isArray(constructors)) return constructors.map((c) => this.box.get(c));
-		const result = {};
-		for (const [key, constructor] of Object.entries(constructors)) result[key] = this.box.get(constructor);
-		return result;
-	}
-};
-/** Builder for creating class instances with constructor dependencies resolved from a {@link Box}. */
-var Construct = class {
-	constructor(box, construct) {
-		this.box = box;
-		this.construct = construct;
-	}
-	/**
-	* Resolves each dependency as a new instance via {@link Box.new},
-	* meaning dependencies are not cached or shared.
-	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
-	*
-	* @example
-	* ```ts
-	* class UserService {
-	*   constructor(private db: Database, private logger: Logger) {}
-	*   static init(box: Box) {
-	*     return box.for(UserService).new(Database, LoggerFactory);
-	*   }
-	* }
-	* ```
-	*/
-	new(...args) {
-		const instances = args.map((arg) => this.box.new(arg));
-		return new this.construct(...instances);
-	}
-	/**
-	* Resolves each dependency as a cached instance via {@link Box.get},
-	* meaning dependencies are shared across the box.
 	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
-	*
-	* @example
-	* ```ts
-	* class UserService {
-	*   constructor(private db: Database, private logger: Logger) {}
-	*   static init(box: Box) {
-	*     return box.for(UserService).get(Database, LoggerFactory);
-	*   }
-	* }
-	* ```
+	* Returns true if an instance existed and has been removed from the box's cache.
 	*/
-	get(...args) {
-		const instances = args.map((arg) => this.box.get(arg));
-		return new this.construct(...instances);
+	static clear(box, constructor) {
+		if (!constructor) {
+			const size = box.cache.size;
+			box.cache.clear();
+			return size > 0;
+		}
+		return box.cache.delete(constructor);
 	}
 };
 /**
 * Builder for creating a `static init` function with constructor dependencies
 * resolved from a {@link Box}.
 */
-var StaticConstruct = class {
+var StaticInit = class {
 	constructor(construct) {
 		this.construct = construct;
 	}
@@ -239,14 +165,13 @@ var StaticConstruct = class {
 	* ```ts
 	* class UserService {
 	*   constructor(private db: Database, private logger: Logger) {}
-	*   static init = Box.init(UserService).get(Database, LoggerFactory);
+	*   static init = Box.init(UserService).new(Database, LoggerFactory);
 	* }
 	* ```
 	*/
 	new(...args) {
 		return (box) => {
-			const instances = args.map((arg) => box.new(arg));
-			return new this.construct(...instances);
+			return new this.construct(...box.new(args));
 		};
 	}
 	/**
@@ -267,11 +192,10 @@ var StaticConstruct = class {
 	*/
 	get(...args) {
 		return (box) => {
-			const instances = args.map((arg) => box.get(arg));
-			return new this.construct(...instances);
+			return new this.construct(...box.get(args));
 		};
 	}
 };
 
 //#endregion
-export { Box, Construct, StaticConstruct, constant, derive, factory, transient };
+export { Box, StaticInit, computed, constant, factory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getbox",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "Lightweight dependency injection for TypeScript",
   "private": false,
   "main": "./dist/index.cjs",