getbox 2.0.0 → 2.1.0

package/README.md

@@ -14,7 +14,7 @@ npm install getbox
 
 ## Usage
 
-`getbox` has a very small API surface. You typically only need `box.get()` and optionally `static init` or the `factory` helper.
+`getbox` has a very small API surface. You typically only need `box.get()` and optionally `Box.init()` or the `factory` helper.
 
 For an alternative pattern using AsyncLocalStorage where classes can resolve dependencies directly, see [getbox/context](./CONTEXT.md).
 
@@ -73,19 +73,35 @@ const service = box.get(UserService);
 service.createUser("Alice");
 ```
 
-`Box.init` is shorthand for writing the `static init` function yourself.
+Use `Box.fn` to write the initializer manually when you need more control.
 
 ```ts
 class UserService {
   constructor(private db: Database, private logger: Logger) {}
 
-  static init(box: Box) {
+  static init = Box.fn((box) => {
     return new UserService(box.get(Database), box.get(LoggerFactory));
-  }
+  });
 }
 ```
 
-If `static init` is defined, it takes priority over the class constructor.
+If a `static init` initializer is defined, it takes priority over the class constructor.
+
+Set `static [boxCache] = false` to opt a class out of caching. The box will call the initializer on every `box.get()` instead of returning a cached instance.
+
+```ts
+import { Box, boxCache } from "getbox";
+
+class RequestContext {
+  timestamp = Date.now();
+  static [boxCache] = false;
+}
+
+const box = new Box();
+const ctx1 = box.get(RequestContext);
+const ctx2 = box.get(RequestContext);
+console.log(ctx1 === ctx2); // false
+```
 
 ### Factory functions
 
@@ -195,6 +211,19 @@ const [db4] = box.new([Database]);
 
 > `box.get()` does not cache `computed` or `constant` values.
 
+`Box` itself can be resolved as a dependency. `box.get(Box)` returns the current box instance.
+
+```ts
+class ServiceLocator {
+  constructor(private box: Box) {}
+  static init = Box.init(ServiceLocator).get(Box);
+}
+
+const box = new Box();
+const locator = box.get(ServiceLocator);
+console.log(locator.box === box); // true
+```
+
 ## Mocking
 
 You can mock dependencies for testing using `Box.mock`.

package/dist/index.cjs

@@ -1,7 +1,18 @@
 
 //#region src/index.ts
-const cacheSymbol = Symbol("Box.cache");
-const isClass = (fn) => fn.prototype !== void 0 && Function.prototype.toString.call(fn).startsWith("class");
+/**
+* Symbol key used to opt a constructor out of caching.
+* When set to `false`, {@link Box.get} will not cache the resolved value.
+*
+* @example
+* ```ts
+* class MyService {
+*   static [boxCache] = false;
+*   static init = Box.init(MyService).get(Database);
+* }
+* ```
+*/
+const boxCache = Symbol("Box.cache");
 /**
 * Creates a {@link Constructor} from a factory function.
 * The factory receives the box as an argument, allowing it to resolve other dependencies.
@@ -16,10 +27,7 @@ const isClass = (fn) => fn.prototype !== void 0 && Function.prototype.toString.c
 * ```
 */
 function factory(init) {
-	return {
-		[cacheSymbol]: true,
-		init
-	};
+	return { init: new Init(init) };
 }
 /**
 * Creates a {@link Constructor} that computes a value from the box without caching the result.
@@ -41,7 +49,10 @@ function factory(init) {
 * ```
 */
 function computed(init) {
-	return { init };
+	return {
+		init: new Init(init),
+		[boxCache]: false
+	};
 }
 /**
 * Creates a {@link Constructor} that always resolves to the given constant value.
@@ -50,20 +61,25 @@ function computed(init) {
 * @example
 * ```ts
 * const ApiUrl = constant("https://api.example.com");
-* const port = box.get(ApiUrl); // "https://api.example.com"
+* const url = box.get(ApiUrl); // "https://api.example.com"
 * ```
 */
 function constant(value) {
-	return { init: () => value };
+	return {
+		init: new Init(() => value),
+		[boxCache]: false
+	};
 }
 /**
 * Dependency injection container that resolves and caches instances from
 * a {@link Constructor}.
 *
-* A constructor is a class with a `static init` function, a class with a
-* no-argument constructor, or a function-based constructor created by
+* A constructor is a class with a `static init` property set to an initializer,
+* a class with a no-argument constructor, or a function-based constructor created by
 * {@link factory}, {@link computed}, or {@link constant}.
 *
+* `Box` can be resolved as a dependency — `box.get(Box)` returns the current instance.
+*
 * @example
 * ```ts
 * class Database {
@@ -80,14 +96,15 @@ function constant(value) {
 * const db = box.get(Database);
 *
 * console.log(service.db === db); // true (cached)
+* console.log(box.get(Box) === box); // true
 * ```
 */
-var Box = class {
+var Box = class Box {
 	cache = /* @__PURE__ */ new Map();
 	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);
+		if (typeof arg === "function") return arg.init instanceof Init ? arg.init.fn(this) : new arg();
+		if (arg.init instanceof Init) return arg.init.fn(this);
 		const result = {};
 		for (const [key, constructor] of Object.entries(arg)) result[key] = this.new(constructor);
 		return result;
@@ -96,14 +113,15 @@ var Box = class {
 		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);
+			if (arg === Box) return this;
+			const value = arg.init instanceof Init ? arg.init.fn(this) : new arg();
+			if (arg[boxCache] !== false) this.cache.set(arg, value);
 			return value;
 		}
-		if ("init" in arg && !isClass(arg.init)) {
+		if (arg.init instanceof 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);
+			const value = arg.init.fn(this);
+			if (arg[boxCache] !== false) this.cache.set(arg, value);
 			return value;
 		}
 		const result = {};
@@ -111,7 +129,7 @@ var Box = class {
 		return result;
 	}
 	/**
-	* Returns a `static init` function builder.
+	* Returns an initializer builder for a class constructor.
 	*
 	* @example
 	* ```ts
@@ -121,8 +139,22 @@ var Box = class {
 	* }
 	* ```
 	*/
-	static init(constructor) {
-		return new StaticInit(constructor);
+	static init(ctor) {
+		return new StaticInit(ctor);
+	}
+	/**
+	* Returns an initializer from a factory function.
+	*
+	* @example
+	* ```ts
+	* class UserService {
+	*   constructor(private db: Database) {}
+	*   static init = Box.fn((box) => new UserService(box.get(Database)));
+	* }
+	* ```
+	*/
+	static fn(fn) {
+		return new Init(fn);
 	}
 	/**
 	* Registers a mock value in the box's cache for a given constructor.
@@ -146,21 +178,21 @@ var Box = class {
 		return box.cache.delete(constructor);
 	}
 };
-/**
-* Builder for creating a `static init` function with constructor dependencies
-* resolved from a {@link Box}.
-*/
+/** An initializer wrapping a factory function for use as a {@link Constructor}. */
+var Init = class {
+	constructor(fn) {
+		this.fn = fn;
+	}
+};
+/** Builder that creates an initializer with dependencies resolved from a {@link Box}. */
 var StaticInit = class {
-	constructor(construct) {
-		this.construct = construct;
+	constructor(ctor) {
+		this.ctor = ctor;
 	}
 	/**
-	* Resolves each dependency as a new instance via {@link Box.new},
-	* meaning dependencies are not cached or shared.
-	* Returns a function compatible with `static init` that can be assigned directly.
-	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
+	* Resolves each dependency as a new instance via {@link Box.new}.
+	* Dependencies are not cached or shared.
+	* Returns an initializer.
 	*
 	* @example
 	* ```ts
@@ -171,17 +203,12 @@ var StaticInit = class {
 	* ```
 	*/
 	new(...args) {
-		return (box) => {
-			return new this.construct(...box.new(args));
-		};
+		return new Init((box) => new this.ctor(...box.new(args)));
 	}
 	/**
-	* Resolves each dependency as a cached instance via {@link Box.get},
-	* meaning dependencies are shared across the box.
-	* Returns a function compatible with `static init` that can be assigned directly.
-	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
+	* Resolves each dependency as a cached instance via {@link Box.get}.
+	* Dependencies are cached and shared.
+	* Returns an initializer.
 	*
 	* @example
 	* ```ts
@@ -192,15 +219,15 @@ var StaticInit = class {
 	* ```
 	*/
 	get(...args) {
-		return (box) => {
-			return new this.construct(...box.get(args));
-		};
+		return new Init((box) => new this.ctor(...box.get(args)));
 	}
 };
 
 //#endregion
 exports.Box = Box;
+exports.Init = Init;
 exports.StaticInit = StaticInit;
+exports.boxCache = boxCache;
 exports.computed = computed;
 exports.constant = constant;
 exports.factory = factory;

package/dist/index.d.cts

@@ -1,18 +1,31 @@
 //#region src/index.d.ts
+/**
+ * Symbol key used to opt a constructor out of caching.
+ * When set to `false`, {@link Box.get} will not cache the resolved value.
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   static [boxCache] = false;
+ *   static init = Box.init(MyService).get(Database);
+ * }
+ * ```
+ */
+declare const boxCache: unique symbol;
 /**
  * A type that can be resolved by a {@link Box}. Either a class with a
- * `static init` function that returns an instance, a class with a
- * no-argument constructor, or a function-based constructor created by
- * {@link factory}, {@link computed}, or {@link constant}.
+ * `static init` property set to an initializer, a class with a no-argument
+ * constructor, or a function-based constructor created by {@link factory},
+ * {@link computed}, or {@link constant}.
  */
 type Constructor<T> = {
-  init(box: Box): T;
+  init: Init<T>;
 } | {
   new (): T;
 };
 /** Extracts the instance type from a {@link Constructor}. */
 type ConstructorInstanceType<T> = T extends {
-  init(box: Box): infer U;
+  init: Init<infer U>;
 } ? U : T extends {
   new (): infer U;
 } ? U : never;
@@ -57,7 +70,7 @@ declare function computed<T>(init: (box: Box) => T): Constructor<T>;
  * @example
  * ```ts
  * const ApiUrl = constant("https://api.example.com");
- * const port = box.get(ApiUrl); // "https://api.example.com"
+ * const url = box.get(ApiUrl); // "https://api.example.com"
  * ```
  */
 declare function constant<const T>(value: T): Constructor<T>;
@@ -65,10 +78,12 @@ declare function constant<const T>(value: T): Constructor<T>;
  * Dependency injection container that resolves and caches instances from
  * a {@link Constructor}.
  *
- * A constructor is a class with a `static init` function, a class with a
- * no-argument constructor, or a function-based constructor created by
+ * A constructor is a class with a `static init` property set to an initializer,
+ * a class with a no-argument constructor, or a function-based constructor created by
  * {@link factory}, {@link computed}, or {@link constant}.
  *
+ * `Box` can be resolved as a dependency — `box.get(Box)` returns the current instance.
+ *
  * @example
  * ```ts
  * class Database {
@@ -85,6 +100,7 @@ declare function constant<const T>(value: T): Constructor<T>;
  * const db = box.get(Database);
  *
  * console.log(service.db === db); // true (cached)
+ * console.log(box.get(Box) === box); // true
  * ```
  */
 declare class Box {
@@ -105,7 +121,7 @@ declare class Box {
   get<const T extends Constructor<any>[]>(constructors: T): { [K in keyof T]: ConstructorInstanceType<T[K]> };
   get<T extends Record<string, Constructor<any>>>(constructors: T): { [K in keyof T]: ConstructorInstanceType<T[K]> };
   /**
-   * Returns a `static init` function builder.
+   * Returns an initializer builder for a class constructor.
    *
    * @example
    * ```ts
@@ -115,7 +131,19 @@ declare class Box {
    * }
    * ```
    */
-  static init<T extends ClassConstructor<any>>(constructor: T): StaticInit<T>;
+  static init<T extends ClassConstructor<any>>(ctor: T): StaticInit<T>;
+  /**
+   * Returns an initializer from a factory function.
+   *
+   * @example
+   * ```ts
+   * class UserService {
+   *   constructor(private db: Database) {}
+   *   static init = Box.fn((box) => new UserService(box.get(Database)));
+   * }
+   * ```
+   */
+  static fn<T>(fn: (box: Box) => T): Init<T>;
   /**
    * Registers a mock value in the box's cache for a given constructor.
    * Useful for replacing dependencies in tests.
@@ -129,20 +157,19 @@ declare class Box {
    */
   static clear<T>(box: Box, constructor?: Constructor<T>): boolean;
 }
-/**
- * Builder for creating a `static init` function with constructor dependencies
- * resolved from a {@link Box}.
- */
-declare class StaticInit<T extends ClassConstructor<any>> {
-  private construct;
-  constructor(construct: T);
+/** An initializer wrapping a factory function for use as a {@link Constructor}. */
+declare class Init<T> {
+  readonly fn: (box: Box) => T;
+  constructor(fn: (box: Box) => T);
+}
+/** Builder that creates an initializer with dependencies resolved from a {@link Box}. */
+declare class StaticInit<C extends ClassConstructor<any>> {
+  private ctor;
+  constructor(ctor: C);
   /**
-   * Resolves each dependency as a new instance via {@link Box.new},
-   * meaning dependencies are not cached or shared.
-   * Returns a function compatible with `static init` that can be assigned directly.
-   *
-   * The returned instance is cached or new depending on whether the
-   * class is retrieved via {@link Box.get} or {@link Box.new}.
+   * Resolves each dependency as a new instance via {@link Box.new}.
+   * Dependencies are not cached or shared.
+   * Returns an initializer.
    *
    * @example
    * ```ts
@@ -152,14 +179,11 @@ declare class StaticInit<T extends ClassConstructor<any>> {
    * }
    * ```
    */
-  new(...args: ClassConstructorArgs<T>): (box: Box) => InstanceType<T>;
+  new(...args: ClassConstructorArgs<C>): Init<InstanceType<C>>;
   /**
-   * Resolves each dependency as a cached instance via {@link Box.get},
-   * meaning dependencies are shared across the box.
-   * Returns a function compatible with `static init` that can be assigned directly.
-   *
-   * The returned instance is cached or new depending on whether the
-   * class is retrieved via {@link Box.get} or {@link Box.new}.
+   * Resolves each dependency as a cached instance via {@link Box.get}.
+   * Dependencies are cached and shared.
+   * Returns an initializer.
    *
    * @example
    * ```ts
@@ -169,13 +193,13 @@ declare class StaticInit<T extends ClassConstructor<any>> {
    * }
    * ```
    */
-  get(...args: ClassConstructorArgs<T>): (box: Box) => InstanceType<T>;
+  get(...args: ClassConstructorArgs<C>): Init<InstanceType<C>>;
 }
 /** A class with any constructor signature. */
 type ClassConstructor<T> = {
   new (...args: any): T;
 };
 /** Maps each constructor parameter to its corresponding {@link Constructor} type. */
-type ClassConstructorArgs<T extends ClassConstructor<any>, Args = ConstructorParameters<T>> = { [K in keyof Args]: Constructor<Args[K]> };
+type ClassConstructorArgs<C extends ClassConstructor<any>, Args = ConstructorParameters<C>> = { [K in keyof Args]: Constructor<Args[K]> };
 //#endregion
-export { Box, Constructor, ConstructorInstanceType, StaticInit, computed, constant, factory };
+export { Box, Constructor, ConstructorInstanceType, Init, StaticInit, boxCache, computed, constant, factory };

package/dist/index.d.mts

@@ -1,18 +1,31 @@
 //#region src/index.d.ts
+/**
+ * Symbol key used to opt a constructor out of caching.
+ * When set to `false`, {@link Box.get} will not cache the resolved value.
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   static [boxCache] = false;
+ *   static init = Box.init(MyService).get(Database);
+ * }
+ * ```
+ */
+declare const boxCache: unique symbol;
 /**
  * A type that can be resolved by a {@link Box}. Either a class with a
- * `static init` function that returns an instance, a class with a
- * no-argument constructor, or a function-based constructor created by
- * {@link factory}, {@link computed}, or {@link constant}.
+ * `static init` property set to an initializer, a class with a no-argument
+ * constructor, or a function-based constructor created by {@link factory},
+ * {@link computed}, or {@link constant}.
  */
 type Constructor<T> = {
-  init(box: Box): T;
+  init: Init<T>;
 } | {
   new (): T;
 };
 /** Extracts the instance type from a {@link Constructor}. */
 type ConstructorInstanceType<T> = T extends {
-  init(box: Box): infer U;
+  init: Init<infer U>;
 } ? U : T extends {
   new (): infer U;
 } ? U : never;
@@ -57,7 +70,7 @@ declare function computed<T>(init: (box: Box) => T): Constructor<T>;
  * @example
  * ```ts
  * const ApiUrl = constant("https://api.example.com");
- * const port = box.get(ApiUrl); // "https://api.example.com"
+ * const url = box.get(ApiUrl); // "https://api.example.com"
  * ```
  */
 declare function constant<const T>(value: T): Constructor<T>;
@@ -65,10 +78,12 @@ declare function constant<const T>(value: T): Constructor<T>;
  * Dependency injection container that resolves and caches instances from
  * a {@link Constructor}.
  *
- * A constructor is a class with a `static init` function, a class with a
- * no-argument constructor, or a function-based constructor created by
+ * A constructor is a class with a `static init` property set to an initializer,
+ * a class with a no-argument constructor, or a function-based constructor created by
  * {@link factory}, {@link computed}, or {@link constant}.
  *
+ * `Box` can be resolved as a dependency — `box.get(Box)` returns the current instance.
+ *
  * @example
  * ```ts
  * class Database {
@@ -85,6 +100,7 @@ declare function constant<const T>(value: T): Constructor<T>;
  * const db = box.get(Database);
  *
  * console.log(service.db === db); // true (cached)
+ * console.log(box.get(Box) === box); // true
  * ```
  */
 declare class Box {
@@ -105,7 +121,7 @@ declare class Box {
   get<const T extends Constructor<any>[]>(constructors: T): { [K in keyof T]: ConstructorInstanceType<T[K]> };
   get<T extends Record<string, Constructor<any>>>(constructors: T): { [K in keyof T]: ConstructorInstanceType<T[K]> };
   /**
-   * Returns a `static init` function builder.
+   * Returns an initializer builder for a class constructor.
    *
    * @example
    * ```ts
@@ -115,7 +131,19 @@ declare class Box {
    * }
    * ```
    */
-  static init<T extends ClassConstructor<any>>(constructor: T): StaticInit<T>;
+  static init<T extends ClassConstructor<any>>(ctor: T): StaticInit<T>;
+  /**
+   * Returns an initializer from a factory function.
+   *
+   * @example
+   * ```ts
+   * class UserService {
+   *   constructor(private db: Database) {}
+   *   static init = Box.fn((box) => new UserService(box.get(Database)));
+   * }
+   * ```
+   */
+  static fn<T>(fn: (box: Box) => T): Init<T>;
   /**
    * Registers a mock value in the box's cache for a given constructor.
    * Useful for replacing dependencies in tests.
@@ -129,20 +157,19 @@ declare class Box {
    */
   static clear<T>(box: Box, constructor?: Constructor<T>): boolean;
 }
-/**
- * Builder for creating a `static init` function with constructor dependencies
- * resolved from a {@link Box}.
- */
-declare class StaticInit<T extends ClassConstructor<any>> {
-  private construct;
-  constructor(construct: T);
+/** An initializer wrapping a factory function for use as a {@link Constructor}. */
+declare class Init<T> {
+  readonly fn: (box: Box) => T;
+  constructor(fn: (box: Box) => T);
+}
+/** Builder that creates an initializer with dependencies resolved from a {@link Box}. */
+declare class StaticInit<C extends ClassConstructor<any>> {
+  private ctor;
+  constructor(ctor: C);
   /**
-   * Resolves each dependency as a new instance via {@link Box.new},
-   * meaning dependencies are not cached or shared.
-   * Returns a function compatible with `static init` that can be assigned directly.
-   *
-   * The returned instance is cached or new depending on whether the
-   * class is retrieved via {@link Box.get} or {@link Box.new}.
+   * Resolves each dependency as a new instance via {@link Box.new}.
+   * Dependencies are not cached or shared.
+   * Returns an initializer.
    *
    * @example
    * ```ts
@@ -152,14 +179,11 @@ declare class StaticInit<T extends ClassConstructor<any>> {
    * }
    * ```
    */
-  new(...args: ClassConstructorArgs<T>): (box: Box) => InstanceType<T>;
+  new(...args: ClassConstructorArgs<C>): Init<InstanceType<C>>;
   /**
-   * Resolves each dependency as a cached instance via {@link Box.get},
-   * meaning dependencies are shared across the box.
-   * Returns a function compatible with `static init` that can be assigned directly.
-   *
-   * The returned instance is cached or new depending on whether the
-   * class is retrieved via {@link Box.get} or {@link Box.new}.
+   * Resolves each dependency as a cached instance via {@link Box.get}.
+   * Dependencies are cached and shared.
+   * Returns an initializer.
    *
    * @example
    * ```ts
@@ -169,13 +193,13 @@ declare class StaticInit<T extends ClassConstructor<any>> {
    * }
    * ```
    */
-  get(...args: ClassConstructorArgs<T>): (box: Box) => InstanceType<T>;
+  get(...args: ClassConstructorArgs<C>): Init<InstanceType<C>>;
 }
 /** A class with any constructor signature. */
 type ClassConstructor<T> = {
   new (...args: any): T;
 };
 /** Maps each constructor parameter to its corresponding {@link Constructor} type. */
-type ClassConstructorArgs<T extends ClassConstructor<any>, Args = ConstructorParameters<T>> = { [K in keyof Args]: Constructor<Args[K]> };
+type ClassConstructorArgs<C extends ClassConstructor<any>, Args = ConstructorParameters<C>> = { [K in keyof Args]: Constructor<Args[K]> };
 //#endregion
-export { Box, Constructor, ConstructorInstanceType, StaticInit, computed, constant, factory };
+export { Box, Constructor, ConstructorInstanceType, Init, StaticInit, boxCache, computed, constant, factory };

package/dist/index.mjs

@@ -1,6 +1,17 @@
 //#region src/index.ts
-const cacheSymbol = Symbol("Box.cache");
-const isClass = (fn) => fn.prototype !== void 0 && Function.prototype.toString.call(fn).startsWith("class");
+/**
+* Symbol key used to opt a constructor out of caching.
+* When set to `false`, {@link Box.get} will not cache the resolved value.
+*
+* @example
+* ```ts
+* class MyService {
+*   static [boxCache] = false;
+*   static init = Box.init(MyService).get(Database);
+* }
+* ```
+*/
+const boxCache = Symbol("Box.cache");
 /**
 * Creates a {@link Constructor} from a factory function.
 * The factory receives the box as an argument, allowing it to resolve other dependencies.
@@ -15,10 +26,7 @@ const isClass = (fn) => fn.prototype !== void 0 && Function.prototype.toString.c
 * ```
 */
 function factory(init) {
-	return {
-		[cacheSymbol]: true,
-		init
-	};
+	return { init: new Init(init) };
 }
 /**
 * Creates a {@link Constructor} that computes a value from the box without caching the result.
@@ -40,7 +48,10 @@ function factory(init) {
 * ```
 */
 function computed(init) {
-	return { init };
+	return {
+		init: new Init(init),
+		[boxCache]: false
+	};
 }
 /**
 * Creates a {@link Constructor} that always resolves to the given constant value.
@@ -49,20 +60,25 @@ function computed(init) {
 * @example
 * ```ts
 * const ApiUrl = constant("https://api.example.com");
-* const port = box.get(ApiUrl); // "https://api.example.com"
+* const url = box.get(ApiUrl); // "https://api.example.com"
 * ```
 */
 function constant(value) {
-	return { init: () => value };
+	return {
+		init: new Init(() => value),
+		[boxCache]: false
+	};
 }
 /**
 * Dependency injection container that resolves and caches instances from
 * a {@link Constructor}.
 *
-* A constructor is a class with a `static init` function, a class with a
-* no-argument constructor, or a function-based constructor created by
+* A constructor is a class with a `static init` property set to an initializer,
+* a class with a no-argument constructor, or a function-based constructor created by
 * {@link factory}, {@link computed}, or {@link constant}.
 *
+* `Box` can be resolved as a dependency — `box.get(Box)` returns the current instance.
+*
 * @example
 * ```ts
 * class Database {
@@ -79,14 +95,15 @@ function constant(value) {
 * const db = box.get(Database);
 *
 * console.log(service.db === db); // true (cached)
+* console.log(box.get(Box) === box); // true
 * ```
 */
-var Box = class {
+var Box = class Box {
 	cache = /* @__PURE__ */ new Map();
 	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);
+		if (typeof arg === "function") return arg.init instanceof Init ? arg.init.fn(this) : new arg();
+		if (arg.init instanceof Init) return arg.init.fn(this);
 		const result = {};
 		for (const [key, constructor] of Object.entries(arg)) result[key] = this.new(constructor);
 		return result;
@@ -95,14 +112,15 @@ var Box = class {
 		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);
+			if (arg === Box) return this;
+			const value = arg.init instanceof Init ? arg.init.fn(this) : new arg();
+			if (arg[boxCache] !== false) this.cache.set(arg, value);
 			return value;
 		}
-		if ("init" in arg && !isClass(arg.init)) {
+		if (arg.init instanceof 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);
+			const value = arg.init.fn(this);
+			if (arg[boxCache] !== false) this.cache.set(arg, value);
 			return value;
 		}
 		const result = {};
@@ -110,7 +128,7 @@ var Box = class {
 		return result;
 	}
 	/**
-	* Returns a `static init` function builder.
+	* Returns an initializer builder for a class constructor.
 	*
 	* @example
 	* ```ts
@@ -120,8 +138,22 @@ var Box = class {
 	* }
 	* ```
 	*/
-	static init(constructor) {
-		return new StaticInit(constructor);
+	static init(ctor) {
+		return new StaticInit(ctor);
+	}
+	/**
+	* Returns an initializer from a factory function.
+	*
+	* @example
+	* ```ts
+	* class UserService {
+	*   constructor(private db: Database) {}
+	*   static init = Box.fn((box) => new UserService(box.get(Database)));
+	* }
+	* ```
+	*/
+	static fn(fn) {
+		return new Init(fn);
 	}
 	/**
 	* Registers a mock value in the box's cache for a given constructor.
@@ -145,21 +177,21 @@ var Box = class {
 		return box.cache.delete(constructor);
 	}
 };
-/**
-* Builder for creating a `static init` function with constructor dependencies
-* resolved from a {@link Box}.
-*/
+/** An initializer wrapping a factory function for use as a {@link Constructor}. */
+var Init = class {
+	constructor(fn) {
+		this.fn = fn;
+	}
+};
+/** Builder that creates an initializer with dependencies resolved from a {@link Box}. */
 var StaticInit = class {
-	constructor(construct) {
-		this.construct = construct;
+	constructor(ctor) {
+		this.ctor = ctor;
 	}
 	/**
-	* Resolves each dependency as a new instance via {@link Box.new},
-	* meaning dependencies are not cached or shared.
-	* Returns a function compatible with `static init` that can be assigned directly.
-	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
+	* Resolves each dependency as a new instance via {@link Box.new}.
+	* Dependencies are not cached or shared.
+	* Returns an initializer.
 	*
 	* @example
 	* ```ts
@@ -170,17 +202,12 @@ var StaticInit = class {
 	* ```
 	*/
 	new(...args) {
-		return (box) => {
-			return new this.construct(...box.new(args));
-		};
+		return new Init((box) => new this.ctor(...box.new(args)));
 	}
 	/**
-	* Resolves each dependency as a cached instance via {@link Box.get},
-	* meaning dependencies are shared across the box.
-	* Returns a function compatible with `static init` that can be assigned directly.
-	*
-	* The returned instance is cached or new depending on whether the
-	* class is retrieved via {@link Box.get} or {@link Box.new}.
+	* Resolves each dependency as a cached instance via {@link Box.get}.
+	* Dependencies are cached and shared.
+	* Returns an initializer.
 	*
 	* @example
 	* ```ts
@@ -191,11 +218,9 @@ var StaticInit = class {
 	* ```
 	*/
 	get(...args) {
-		return (box) => {
-			return new this.construct(...box.get(args));
-		};
+		return new Init((box) => new this.ctor(...box.get(args)));
 	}
 };
 
 //#endregion
-export { Box, StaticInit, computed, constant, factory };
+export { Box, Init, StaticInit, boxCache, computed, constant, factory };

package/package.json

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