@navios/di 0.1.8 → 0.1.10

package/lib/index.js

@@ -0,0 +1,791 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+require("zod");
+
+//#region src/enums/injectable-scope.enum.mts
+let InjectableScope = /* @__PURE__ */ function(InjectableScope$1) {
+	/**
+	* Singleton scope: The instance is created once and shared across the application.
+	*/
+	InjectableScope$1["Singleton"] = "Singleton";
+	/**
+	* Instance scope: A new instance is created for each injection.
+	*/
+	InjectableScope$1["Instance"] = "Instance";
+	return InjectableScope$1;
+}({});
+
+//#endregion
+//#region src/enums/injectable-type.enum.mts
+let InjectableType = /* @__PURE__ */ function(InjectableType$1) {
+	InjectableType$1["Class"] = "Class";
+	InjectableType$1["Factory"] = "Factory";
+	return InjectableType$1;
+}({});
+
+//#endregion
+//#region src/injection-token.mts
+var InjectionToken = class InjectionToken {
+	id = globalThis.crypto.randomUUID();
+	formattedName = null;
+	constructor(name, schema) {
+		this.name = name;
+		this.schema = schema;
+	}
+	static create(name, schema) {
+		return new InjectionToken(name, schema);
+	}
+	static bound(token, value) {
+		return new BoundInjectionToken(token, value);
+	}
+	static factory(token, factory) {
+		return new FactoryInjectionToken(token, factory);
+	}
+	static refineType(token) {
+		return token;
+	}
+	toString() {
+		if (this.formattedName) return this.formattedName;
+		const { name } = this;
+		if (typeof name === "function") {
+			const className = name.name;
+			this.formattedName = `${className}(${this.id})`;
+		} else if (typeof name === "symbol") this.formattedName = `${name.toString()}(${this.id})`;
+		else this.formattedName = `${name}(${this.id})`;
+		return this.formattedName;
+	}
+};
+var BoundInjectionToken = class {
+	id;
+	name;
+	schema;
+	constructor(token, value) {
+		this.token = token;
+		this.value = value;
+		this.name = token.name;
+		this.id = token.id;
+		this.schema = token.schema;
+	}
+	toString() {
+		return this.token.toString();
+	}
+};
+var FactoryInjectionToken = class {
+	value;
+	resolved = false;
+	id;
+	name;
+	schema;
+	constructor(token, factory) {
+		this.token = token;
+		this.factory = factory;
+		this.name = token.name;
+		this.id = token.id;
+		this.schema = token.schema;
+	}
+	async resolve() {
+		if (!this.value) {
+			this.value = await this.factory();
+			this.resolved = true;
+		}
+		return this.value;
+	}
+	toString() {
+		return this.token.toString();
+	}
+};
+
+//#endregion
+//#region src/registry.mts
+var Registry = class {
+	factories = new Map();
+	constructor(parent) {
+		this.parent = parent;
+	}
+	has(token) {
+		if (this.factories.has(token.id)) return true;
+		if (this.parent) return this.parent.has(token);
+		return false;
+	}
+	get(token) {
+		const factory = this.factories.get(token.id);
+		if (!factory) {
+			if (this.parent) return this.parent.get(token);
+			throw new Error(`[Registry] No factory found for ${token.toString()}`);
+		}
+		return factory;
+	}
+	set(token, factory, scope) {
+		this.factories.set(token.id, {
+			factory,
+			scope,
+			originalToken: token
+		});
+	}
+	delete(token) {
+		this.factories.delete(token.id);
+	}
+};
+const globalRegistry = new Registry();
+
+//#endregion
+//#region src/proxy-service-locator.mts
+var ProxyServiceLocator = class {
+	constructor(serviceLocator, ctx) {
+		this.serviceLocator = serviceLocator;
+		this.ctx = ctx;
+	}
+	getEventBus() {
+		return this.serviceLocator.getEventBus();
+	}
+	getInstance(token, args) {
+		return this.ctx.inject(token, args).then((instance) => {
+			return [void 0, instance];
+		}, (error) => {
+			return [error];
+		});
+	}
+	getOrThrowInstance(token, args) {
+		return this.ctx.inject(token, args);
+	}
+	getSyncInstance(token, args) {
+		return this.serviceLocator.getSyncInstance(token, args);
+	}
+	invalidate(service, round) {
+		return this.serviceLocator.invalidate(service, round);
+	}
+	ready() {
+		return this.serviceLocator.ready();
+	}
+	makeInstanceName(token, args) {
+		return this.serviceLocator.makeInstanceName(token, args);
+	}
+};
+function makeProxyServiceLocator(serviceLocator, ctx) {
+	return new ProxyServiceLocator(serviceLocator, ctx);
+}
+
+//#endregion
+//#region src/symbols/injectable-token.mts
+const InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+
+//#endregion
+//#region src/utils/get-injectors.mts
+const InjectorsBase = new Map();
+function getInjectors({ baseLocator }) {
+	if (InjectorsBase.has(baseLocator)) return InjectorsBase.get(baseLocator);
+	let currentLocator = baseLocator;
+	function getServiceLocator() {
+		if (!currentLocator) throw new Error("[Injector] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.");
+		return currentLocator;
+	}
+	function provideServiceLocator$1(locator) {
+		const original = currentLocator;
+		currentLocator = locator;
+		return original;
+	}
+	function inject$1(token, args) {
+		const realToken = token[InjectableTokenMeta] ?? token;
+		return getServiceLocator().getOrThrowInstance(realToken, args);
+	}
+	let promiseCollector = null;
+	function wrapSyncInit$1(cb) {
+		return () => {
+			const promises = [];
+			const originalPromiseCollector = promiseCollector;
+			promiseCollector = (promise) => {
+				promises.push(promise);
+			};
+			const result = cb();
+			promiseCollector = originalPromiseCollector;
+			return [result, promises];
+		};
+	}
+	function syncInject$1(token, args) {
+		const realToken = token[InjectableTokenMeta] ?? token;
+		const instance = getServiceLocator().getSyncInstance(realToken, args);
+		if (!instance) if (promiseCollector) {
+			const promise = getServiceLocator().getInstance(realToken, args);
+			promiseCollector(promise);
+		} else throw new Error(`[Injector] Cannot initiate ${realToken.toString()}`);
+		return instance;
+	}
+	const injectors = {
+		inject: inject$1,
+		syncInject: syncInject$1,
+		wrapSyncInit: wrapSyncInit$1,
+		provideServiceLocator: provideServiceLocator$1
+	};
+	InjectorsBase.set(baseLocator, injectors);
+	return injectors;
+}
+
+//#endregion
+//#region src/utils/get-injectable-token.mts
+function getInjectableToken(target) {
+	const token = target[InjectableTokenMeta];
+	if (!token) throw new Error(`[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`);
+	return token;
+}
+
+//#endregion
+//#region src/resolve-service.mts
+async function resolveService(ctx, target, args = []) {
+	const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx);
+	const { wrapSyncInit: wrapSyncInit$1, provideServiceLocator: provideServiceLocator$1 } = getInjectors({ baseLocator: ctx.locator });
+	const tryLoad = wrapSyncInit$1(() => {
+		const original = provideServiceLocator$1(proxyServiceLocator);
+		let result = new target(...args);
+		provideServiceLocator$1(original);
+		return result;
+	});
+	let [instance, promises] = tryLoad();
+	if (promises.length > 0) {
+		await Promise.all(promises);
+		const newRes = tryLoad();
+		instance = newRes[0];
+		promises = newRes[1];
+	}
+	if (promises.length > 0) {
+		console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
+
+     One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
+
+     Please use inject instead of syncInject to load those dependencies.`);
+		throw new Error(`[ServiceLocator] Service ${target.name} cannot be instantiated.`);
+	}
+	return instance;
+}
+
+//#endregion
+//#region src/decorators/injectable.decorator.mts
+function Injectable({ scope = InjectableScope.Singleton, type = InjectableType.Class, token, registry = globalRegistry } = {}) {
+	return (target, context) => {
+		if (context.kind !== "class") throw new Error("[ServiceLocator] @Injectable decorator can only be used on classes.");
+		let injectableToken = token ?? InjectionToken.create(target);
+		if (type === InjectableType.Class) registry.set(injectableToken, async (ctx, args) => resolveService(ctx, target, [args]), scope);
+		else if (type === InjectableType.Factory) registry.set(injectableToken, async (ctx, args) => {
+			const builder = await resolveService(ctx, target);
+			if (typeof builder.create !== "function") throw new Error(`[ServiceLocator] Factory ${target.name} does not implement the create method.`);
+			return builder.create(ctx, args);
+		}, scope);
+		target[InjectableTokenMeta] = injectableToken;
+		return target;
+	};
+}
+
+//#endregion
+//#region src/errors/errors.enum.mts
+let ErrorsEnum = /* @__PURE__ */ function(ErrorsEnum$1) {
+	ErrorsEnum$1["InstanceExpired"] = "InstanceExpired";
+	ErrorsEnum$1["InstanceNotFound"] = "InstanceNotFound";
+	ErrorsEnum$1["InstanceDestroying"] = "InstanceDestroying";
+	ErrorsEnum$1["UnknownError"] = "UnknownError";
+	ErrorsEnum$1["FactoryNotFound"] = "FactoryNotFound";
+	ErrorsEnum$1["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
+	return ErrorsEnum$1;
+}({});
+
+//#endregion
+//#region src/errors/factory-not-found.mts
+var FactoryNotFound = class extends Error {
+	code = ErrorsEnum.FactoryNotFound;
+	constructor(name) {
+		super(`Factory ${name} not found`);
+		this.name = name;
+	}
+};
+
+//#endregion
+//#region src/errors/factory-token-not-resolved.mts
+var FactoryTokenNotResolved = class extends Error {
+	code = ErrorsEnum.FactoryTokenNotResolved;
+	constructor(name) {
+		super(`Factory token not resolved: ${name.toString()}`);
+	}
+};
+
+//#endregion
+//#region src/errors/instance-destroying.mts
+var InstanceDestroying = class extends Error {
+	code = ErrorsEnum.InstanceDestroying;
+	constructor(name) {
+		super(`Instance ${name} destroying`);
+		this.name = name;
+	}
+};
+
+//#endregion
+//#region src/errors/instance-expired.mts
+var InstanceExpired = class extends Error {
+	code = ErrorsEnum.InstanceExpired;
+	constructor(name) {
+		super(`Instance ${name} expired`);
+		this.name = name;
+	}
+};
+
+//#endregion
+//#region src/errors/instance-not-found.mts
+var InstanceNotFound = class extends Error {
+	code = ErrorsEnum.InstanceNotFound;
+	constructor(name) {
+		super(`Instance ${name} not found`);
+		this.name = name;
+	}
+};
+
+//#endregion
+//#region src/errors/unknown-error.mts
+var UnknownError = class extends Error {
+	code = ErrorsEnum.UnknownError;
+	parent;
+	constructor(message) {
+		if (message instanceof Error) {
+			super(message.message);
+			this.parent = message;
+			return;
+		}
+		super(message);
+	}
+};
+
+//#endregion
+//#region src/event-emitter.mts
+var EventEmitter = class {
+	listeners = new Map();
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+		this.listeners.get(event).add(listener);
+		return () => {
+			this.off(event, listener);
+		};
+	}
+	off(event, listener) {
+		if (!this.listeners.has(event)) return;
+		this.listeners.get(event).delete(listener);
+		if (this.listeners.get(event).size === 0) this.listeners.delete(event);
+	}
+	once(event, listener) {
+		const off = this.on(event, (...args) => {
+			off();
+			listener(...args);
+		});
+		return off;
+	}
+	async emit(event, ...args) {
+		if (!this.listeners.has(event)) return;
+		return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
+	}
+	addChannel(ns, event, target) {
+		return this.on(event, (...args) => target.emit(ns, event, ...args));
+	}
+};
+
+//#endregion
+//#region src/service-locator-event-bus.mts
+var ServiceLocatorEventBus = class {
+	listeners = new Map();
+	constructor(logger = null) {
+		this.logger = logger;
+	}
+	on(ns, event, listener) {
+		this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
+		if (!this.listeners.has(ns)) this.listeners.set(ns, new Map());
+		const nsEvents = this.listeners.get(ns);
+		if (!nsEvents.has(event)) nsEvents.set(event, new Set());
+		nsEvents.get(event).add(listener);
+		return () => {
+			nsEvents.get(event).delete(listener);
+			if (nsEvents.get(event)?.size === 0) nsEvents.delete(event);
+			if (nsEvents.size === 0) this.listeners.delete(ns);
+		};
+	}
+	async emit(key, event) {
+		if (!this.listeners.has(key)) return;
+		const events = this.listeners.get(key);
+		const preEvent = `pre:${event}`;
+		const postEvent = `post:${event}`;
+		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
+		await Promise.allSettled([...events.get(preEvent) ?? []].map((listener) => listener(preEvent))).then((results) => {
+			results.filter((result) => result.status === "rejected").forEach((result) => {
+				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`, result.reason);
+			});
+		});
+		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
+		const res = await Promise.allSettled([...events.get(event) ?? []].map((listener) => listener(event))).then((results) => {
+			const res$1 = results.filter((result) => result.status === "rejected").map((result) => {
+				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`, result.reason);
+				return result;
+			});
+			if (res$1.length > 0) return Promise.reject(res$1);
+			return results;
+		});
+		this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
+		await Promise.allSettled([...events.get(postEvent) ?? []].map((listener) => listener(postEvent))).then((results) => {
+			results.filter((result) => result.status === "rejected").forEach((result) => {
+				this.logger?.warn(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`, result.reason);
+			});
+		});
+		return res;
+	}
+};
+
+//#endregion
+//#region src/service-locator-instance-holder.mts
+let ServiceLocatorInstanceHolderKind = /* @__PURE__ */ function(ServiceLocatorInstanceHolderKind$1) {
+	ServiceLocatorInstanceHolderKind$1["Instance"] = "instance";
+	ServiceLocatorInstanceHolderKind$1["Factory"] = "factory";
+	ServiceLocatorInstanceHolderKind$1["AbstractFactory"] = "abstractFactory";
+	return ServiceLocatorInstanceHolderKind$1;
+}({});
+let ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ function(ServiceLocatorInstanceHolderStatus$1) {
+	ServiceLocatorInstanceHolderStatus$1["Created"] = "created";
+	ServiceLocatorInstanceHolderStatus$1["Creating"] = "creating";
+	ServiceLocatorInstanceHolderStatus$1["Destroying"] = "destroying";
+	return ServiceLocatorInstanceHolderStatus$1;
+}({});
+
+//#endregion
+//#region src/service-locator-manager.mts
+var ServiceLocatorManager = class {
+	instancesHolders = new Map();
+	constructor(logger = null) {
+		this.logger = logger;
+	}
+	get(name) {
+		const holder = this.instancesHolders.get(name);
+		if (holder) {
+			if (holder.ttl !== Infinity) {
+				const now = Date.now();
+				if (now - holder.createdAt > holder.ttl) {
+					this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`);
+					return [new InstanceExpired(holder.name), holder];
+				}
+			} else if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
+				this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`);
+				return [new InstanceDestroying(holder.name), holder];
+			}
+			return [void 0, holder];
+		} else {
+			this.logger?.log(`[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`);
+			return [new InstanceNotFound(name)];
+		}
+	}
+	set(name, holder) {
+		this.instancesHolders.set(name, holder);
+	}
+	has(name) {
+		const [error, holder] = this.get(name);
+		if (!error) return [void 0, true];
+		if ([ErrorsEnum.InstanceExpired, ErrorsEnum.InstanceDestroying].includes(error.code)) return [error];
+		return [void 0, !!holder];
+	}
+	delete(name) {
+		return this.instancesHolders.delete(name);
+	}
+	filter(predicate) {
+		return new Map([...this.instancesHolders].filter(([key, value]) => predicate(value, key)));
+	}
+};
+
+//#endregion
+//#region src/service-locator.mts
+var ServiceLocator = class {
+	eventBus;
+	manager;
+	constructor(registry = globalRegistry, logger = null) {
+		this.registry = registry;
+		this.logger = logger;
+		this.eventBus = new ServiceLocatorEventBus(logger);
+		this.manager = new ServiceLocatorManager(logger);
+	}
+	getEventBus() {
+		return this.eventBus;
+	}
+	storeInstance(instance, token, args) {
+		const instanceName = this.getInstanceIdentifier(token, args);
+		this.manager.set(instanceName, {
+			name: instanceName,
+			instance,
+			status: ServiceLocatorInstanceHolderStatus.Created,
+			kind: ServiceLocatorInstanceHolderKind.Instance,
+			createdAt: Date.now(),
+			ttl: Infinity,
+			deps: [],
+			destroyListeners: [],
+			effects: [],
+			destroyPromise: null,
+			creationPromise: null
+		});
+		this.notifyListeners(instanceName);
+	}
+	removeInstance(token, args) {
+		const instanceName = this.getInstanceIdentifier(token, args);
+		return this.invalidate(instanceName);
+	}
+	resolveTokenArgs(token, args) {
+		let realArgs = args;
+		if (token instanceof BoundInjectionToken) realArgs = token.value;
+		else if (token instanceof FactoryInjectionToken) if (token.resolved) realArgs = token.value;
+		else return [new FactoryTokenNotResolved(token.name)];
+		if (!token.schema) return [void 0, realArgs];
+		const validatedArgs = token.schema?.safeParse(realArgs);
+		if (validatedArgs && !validatedArgs.success) {
+			this.logger?.error(`[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`, validatedArgs.error);
+			return [new UnknownError(validatedArgs.error)];
+		}
+		return [void 0, validatedArgs?.data];
+	}
+	getInstanceIdentifier(token, args) {
+		const [err, realArgs] = this.resolveTokenArgs(token, args);
+		if (err) throw err;
+		return this.makeInstanceName(token, realArgs);
+	}
+	async getInstance(token, args) {
+		const [err, realArgs] = this.resolveTokenArgs(token, args);
+		if (err instanceof UnknownError) return [err];
+		else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
+			await token.resolve();
+			return this.getInstance(token, args);
+		}
+		const instanceName = this.makeInstanceName(token, realArgs);
+		const [error, holder] = this.manager.get(instanceName);
+		if (!error) {
+			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) return holder.creationPromise;
+			else if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) return [new UnknownError(ErrorsEnum.InstanceDestroying)];
+			return [void 0, holder.instance];
+		}
+		switch (error.code) {
+			case ErrorsEnum.InstanceDestroying:
+				this.logger?.log(`[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`);
+				await holder?.destroyPromise;
+				return this.getInstance(token, args);
+			case ErrorsEnum.InstanceExpired:
+				this.logger?.log(`[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`);
+				await this.invalidate(instanceName);
+				return this.getInstance(token, args);
+			case ErrorsEnum.InstanceNotFound: break;
+			default: return [error];
+		}
+		return this.createInstance(instanceName, token, realArgs);
+	}
+	async getOrThrowInstance(token, args) {
+		const [error, instance] = await this.getInstance(token, args);
+		if (error) throw error;
+		return instance;
+	}
+	notifyListeners(name, event = "create") {
+		this.logger?.log(`[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`);
+		return this.eventBus.emit(name, event);
+	}
+	async createInstance(instanceName, token, args) {
+		this.logger?.log(`[ServiceLocator]#createInstance() Creating instance for ${instanceName}`);
+		let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
+		if (this.registry.has(realToken)) return this.resolveInstance(instanceName, realToken, args);
+		else return [new FactoryNotFound(realToken.name.toString())];
+	}
+	async resolveInstance(instanceName, token, args) {
+		this.logger?.log(`[ServiceLocator]#resolveInstance(): Creating instance for ${instanceName} from abstract factory`);
+		const ctx = this.createFactoryContext(instanceName);
+		let { factory, scope } = this.registry.get(token);
+		const holder = {
+			name: instanceName,
+			instance: null,
+			status: ServiceLocatorInstanceHolderStatus.Creating,
+			kind: ServiceLocatorInstanceHolderKind.AbstractFactory,
+			creationPromise: factory(ctx, args).then(async (instance) => {
+				holder.instance = instance;
+				holder.status = ServiceLocatorInstanceHolderStatus.Created;
+				holder.deps = ctx.getDependencies();
+				holder.destroyListeners = ctx.getDestroyListeners();
+				holder.ttl = ctx.getTtl();
+				if (holder.deps.length > 0) {
+					this.logger?.log(`[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(", ")}`);
+					holder.deps.forEach((dependency) => {
+						holder.destroyListeners.push(this.eventBus.on(dependency, "destroy", () => this.invalidate(instanceName)));
+					});
+				}
+				if (holder.ttl === 0 || scope === InjectableScope.Instance) await this.invalidate(instanceName);
+				await this.notifyListeners(instanceName);
+				return [void 0, instance];
+			}).catch((error) => {
+				this.logger?.error(`[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`, error);
+				return [new UnknownError(error)];
+			}),
+			effects: [],
+			deps: [],
+			destroyListeners: [],
+			createdAt: Date.now(),
+			ttl: Infinity
+		};
+		if (scope === InjectableScope.Singleton) this.manager.set(instanceName, holder);
+		return holder.creationPromise;
+	}
+	createFactoryContext(instanceName) {
+		const dependencies = new Set();
+		const destroyListeners = new Set();
+		const self = this;
+		function invalidate(name = instanceName) {
+			return self.invalidate(name);
+		}
+		function addEffect(listener) {
+			destroyListeners.add(listener);
+		}
+		let ttl = Infinity;
+		function setTtl(value) {
+			ttl = value;
+		}
+		function getTtl() {
+			return ttl;
+		}
+		function on(key, event, listener) {
+			destroyListeners.add(self.eventBus.on(key, event, listener));
+		}
+		return {
+			async inject(token, args) {
+				let injectionToken = token;
+				if (typeof token === "function") injectionToken = getInjectableToken(token);
+				if (injectionToken instanceof InjectionToken) {
+					const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
+					const instanceName$1 = self.makeInstanceName(token, validatedArgs);
+					dependencies.add(instanceName$1);
+					return self.getOrThrowInstance(injectionToken, args);
+				}
+				throw new Error(`[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`);
+			},
+			invalidate,
+			on,
+			getDependencies: () => Array.from(dependencies),
+			addEffect,
+			getDestroyListeners: () => Array.from(destroyListeners),
+			setTtl,
+			getTtl,
+			locator: self
+		};
+	}
+	getSyncInstance(token, args) {
+		const [err, realArgs] = this.resolveTokenArgs(token, args);
+		if (err) return null;
+		const instanceName = this.makeInstanceName(token, realArgs);
+		const [error, holder] = this.manager.get(instanceName);
+		if (error) return null;
+		return holder.instance;
+	}
+	invalidate(service, round = 1) {
+		this.logger?.log(`[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`);
+		const toInvalidate = this.manager.filter((holder) => holder.name === service || holder.deps.includes(service));
+		const promises = [];
+		for (const [key, holder] of toInvalidate.entries()) {
+			if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
+				this.logger?.trace(`[ServiceLocator]#invalidate(): ${key} is already being destroyed`);
+				promises.push(holder.destroyPromise);
+				continue;
+			}
+			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
+				this.logger?.trace(`[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`);
+				promises.push(holder.creationPromise?.then(() => {
+					if (round > 3) {
+						this.logger?.error(`[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`);
+						return;
+					}
+					return this.invalidate(key, round + 1);
+				}));
+				continue;
+			}
+			holder.status = ServiceLocatorInstanceHolderStatus.Destroying;
+			this.logger?.log(`[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`);
+			holder.destroyPromise = Promise.all(holder.destroyListeners.map((listener) => listener())).then(async () => {
+				this.manager.delete(key);
+				await this.notifyListeners(key, "destroy");
+			});
+			promises.push(holder.destroyPromise);
+		}
+		return Promise.all(promises);
+	}
+	async ready() {
+		return Promise.all(Array.from(this.manager.filter(() => true)).map(([, holder]) => {
+			if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) return holder.creationPromise?.then(() => null);
+			if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) return holder.destroyPromise.then(() => null);
+			return Promise.resolve(null);
+		})).then(() => null);
+	}
+	makeInstanceName(token, args) {
+		const formattedArgs = args ? ":" + JSON.stringify(args, (_, value) => {
+			if (typeof value === "function") return `function:${value.name}(${value.length})`;
+			if (typeof value === "symbol") return value.toString();
+			return value;
+		}).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
+		return `${token.toString()}${formattedArgs}`;
+	}
+};
+
+//#endregion
+//#region src/injector.mts
+const globalServiceLocator = new ServiceLocator();
+function getGlobalServiceLocator() {
+	if (!globalServiceLocator) throw new Error("[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.");
+	return globalServiceLocator;
+}
+const values = getInjectors({ baseLocator: globalServiceLocator });
+const inject = values.inject;
+const syncInject = values.syncInject;
+const wrapSyncInit = values.wrapSyncInit;
+const provideServiceLocator = values.provideServiceLocator;
+
+//#endregion
+exports.BoundInjectionToken = BoundInjectionToken;
+exports.ErrorsEnum = ErrorsEnum;
+exports.EventEmitter = EventEmitter;
+exports.FactoryInjectionToken = FactoryInjectionToken;
+exports.FactoryNotFound = FactoryNotFound;
+exports.FactoryTokenNotResolved = FactoryTokenNotResolved;
+exports.Injectable = Injectable;
+exports.InjectableScope = InjectableScope;
+exports.InjectableTokenMeta = InjectableTokenMeta;
+exports.InjectableType = InjectableType;
+exports.InjectionToken = InjectionToken;
+exports.InjectorsBase = InjectorsBase;
+exports.InstanceDestroying = InstanceDestroying;
+exports.InstanceExpired = InstanceExpired;
+exports.InstanceNotFound = InstanceNotFound;
+exports.ProxyServiceLocator = ProxyServiceLocator;
+exports.Registry = Registry;
+exports.ServiceLocator = ServiceLocator;
+exports.ServiceLocatorEventBus = ServiceLocatorEventBus;
+exports.ServiceLocatorInstanceHolderKind = ServiceLocatorInstanceHolderKind;
+exports.ServiceLocatorInstanceHolderStatus = ServiceLocatorInstanceHolderStatus;
+exports.ServiceLocatorManager = ServiceLocatorManager;
+exports.UnknownError = UnknownError;
+exports.getGlobalServiceLocator = getGlobalServiceLocator;
+exports.getInjectableToken = getInjectableToken;
+exports.getInjectors = getInjectors;
+exports.globalRegistry = globalRegistry;
+exports.inject = inject;
+exports.makeProxyServiceLocator = makeProxyServiceLocator;
+exports.provideServiceLocator = provideServiceLocator;
+exports.resolveService = resolveService;
+exports.syncInject = syncInject;
+exports.wrapSyncInit = wrapSyncInit;