@navios/di 0.1.7 → 0.1.9

package/dist/index.mjs

@@ -1,967 +0,0 @@
-// packages/di/src/decorators/injectable.decorator.mts
-import { NaviosException as NaviosException2 } from "@navios/common";
-import "zod";
-
-// packages/di/src/enums/injectable-scope.enum.mts
-var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
-  InjectableScope3["Singleton"] = "Singleton";
-  InjectableScope3["Instance"] = "Instance";
-  return InjectableScope3;
-})(InjectableScope || {});
-
-// packages/di/src/enums/injectable-type.enum.mts
-var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
-  InjectableType2["Class"] = "Class";
-  InjectableType2["Factory"] = "Factory";
-  return InjectableType2;
-})(InjectableType || {});
-
-// packages/di/src/injection-token.mts
-import { randomUUID } from "crypto";
-import "zod";
-var InjectionToken = class _InjectionToken {
-  constructor(name, schema) {
-    this.name = name;
-    this.schema = schema;
-  }
-  id = randomUUID();
-  formattedName = null;
-  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 {
-  constructor(token, value) {
-    this.token = token;
-    this.value = value;
-    this.name = token.name;
-    this.id = token.id;
-    this.schema = token.schema;
-  }
-  id;
-  name;
-  schema;
-  toString() {
-    return this.token.toString();
-  }
-};
-var FactoryInjectionToken = class {
-  constructor(token, factory) {
-    this.token = token;
-    this.factory = factory;
-    this.name = token.name;
-    this.id = token.id;
-    this.schema = token.schema;
-  }
-  value;
-  resolved = false;
-  id;
-  name;
-  schema;
-  async resolve() {
-    if (!this.value) {
-      this.value = await this.factory();
-      this.resolved = true;
-    }
-    return this.value;
-  }
-  toString() {
-    return this.token.toString();
-  }
-};
-
-// packages/di/src/registry.mts
-import "zod";
-var Registry = class {
-  constructor(parent) {
-    this.parent = parent;
-  }
-  factories = /* @__PURE__ */ new Map();
-  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);
-  }
-};
-var globalRegistry = new Registry();
-
-// packages/di/src/resolve-service.mts
-import { NaviosException } from "@navios/common";
-
-// packages/di/src/proxy-service-locator.mts
-var ProxyServiceLocator = class {
-  constructor(serviceLocator, ctx) {
-    this.serviceLocator = serviceLocator;
-    this.ctx = ctx;
-  }
-  getEventBus() {
-    return this.serviceLocator.getEventBus();
-  }
-  // @ts-expect-error We don't need all the properties of the class
-  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);
-}
-
-// packages/di/src/symbols/injectable-token.mts
-var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
-
-// packages/di/src/utils/get-injectors.mts
-var InjectorsBase = /* @__PURE__ */ 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 provideServiceLocator2(locator) {
-    const original = currentLocator;
-    currentLocator = locator;
-    return original;
-  }
-  function inject2(token, args) {
-    const realToken = token[InjectableTokenMeta] ?? token;
-    return getServiceLocator().getOrThrowInstance(realToken, args);
-  }
-  let promiseCollector = null;
-  function wrapSyncInit2(cb) {
-    return () => {
-      const promises = [];
-      const originalPromiseCollector = promiseCollector;
-      promiseCollector = (promise) => {
-        promises.push(promise);
-      };
-      const result = cb();
-      promiseCollector = originalPromiseCollector;
-      return [result, promises];
-    };
-  }
-  function syncInject2(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: inject2,
-    syncInject: syncInject2,
-    wrapSyncInit: wrapSyncInit2,
-    provideServiceLocator: provideServiceLocator2
-  };
-  InjectorsBase.set(baseLocator, injectors);
-  return injectors;
-}
-
-// packages/di/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;
-}
-
-// packages/di/src/resolve-service.mts
-async function resolveService(ctx, target, args = []) {
-  const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx);
-  const { wrapSyncInit: wrapSyncInit2, provideServiceLocator: provideServiceLocator2 } = getInjectors({
-    baseLocator: ctx.locator
-  });
-  const tryLoad = wrapSyncInit2(() => {
-    const original = provideServiceLocator2(proxyServiceLocator);
-    let result = new target(...args);
-    provideServiceLocator2(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 NaviosException(
-      `[ServiceLocator] Service ${target.name} cannot be instantiated.`
-    );
-  }
-  return instance;
-}
-
-// packages/di/src/decorators/injectable.decorator.mts
-function Injectable({
-  scope = "Singleton" /* Singleton */,
-  type = "Class" /* 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 === "Class" /* Class */) {
-      registry.set(
-        injectableToken,
-        async (ctx, args) => resolveService(ctx, target, [args]),
-        scope
-      );
-    } else if (type === "Factory" /* Factory */) {
-      registry.set(
-        injectableToken,
-        async (ctx, args) => {
-          const builder = await resolveService(ctx, target);
-          if (typeof builder.create !== "function") {
-            throw new NaviosException2(
-              `[ServiceLocator] Factory ${target.name} does not implement the create method.`
-            );
-          }
-          return builder.create(ctx, args);
-        },
-        scope
-      );
-    }
-    target[InjectableTokenMeta] = injectableToken;
-    return target;
-  };
-}
-
-// packages/di/src/errors/errors.enum.mts
-var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
-  ErrorsEnum2["InstanceExpired"] = "InstanceExpired";
-  ErrorsEnum2["InstanceNotFound"] = "InstanceNotFound";
-  ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
-  ErrorsEnum2["UnknownError"] = "UnknownError";
-  ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
-  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
-  return ErrorsEnum2;
-})(ErrorsEnum || {});
-
-// packages/di/src/errors/factory-not-found.mts
-var FactoryNotFound = class extends Error {
-  constructor(name) {
-    super(`Factory ${name} not found`);
-    this.name = name;
-  }
-  code = "FactoryNotFound" /* FactoryNotFound */;
-};
-
-// packages/di/src/errors/factory-token-not-resolved.mts
-var FactoryTokenNotResolved = class extends Error {
-  code = "FactoryTokenNotResolved" /* FactoryTokenNotResolved */;
-  constructor(name) {
-    super(`Factory token not resolved: ${name.toString()}`);
-  }
-};
-
-// packages/di/src/errors/instance-destroying.mts
-var InstanceDestroying = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} destroying`);
-    this.name = name;
-  }
-  code = "InstanceDestroying" /* InstanceDestroying */;
-};
-
-// packages/di/src/errors/instance-expired.mts
-var InstanceExpired = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} expired`);
-    this.name = name;
-  }
-  code = "InstanceExpired" /* InstanceExpired */;
-};
-
-// packages/di/src/errors/instance-not-found.mts
-var InstanceNotFound = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} not found`);
-    this.name = name;
-  }
-  code = "InstanceNotFound" /* InstanceNotFound */;
-};
-
-// packages/di/src/errors/unknown-error.mts
-var UnknownError = class extends Error {
-  code = "UnknownError" /* UnknownError */;
-  parent;
-  constructor(message) {
-    if (message instanceof Error) {
-      super(message.message);
-      this.parent = message;
-      return;
-    }
-    super(message);
-  }
-};
-
-// packages/di/src/interfaces/factory.interface.mts
-import "zod";
-
-// packages/di/src/event-emitter.mts
-var EventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ 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));
-  }
-};
-
-// packages/di/src/service-locator-event-bus.mts
-var ServiceLocatorEventBus = class {
-  constructor(logger = null) {
-    this.logger = logger;
-  }
-  listeners = /* @__PURE__ */ new Map();
-  on(ns, event, listener) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
-    if (!this.listeners.has(ns)) {
-      this.listeners.set(ns, /* @__PURE__ */ new Map());
-    }
-    const nsEvents = this.listeners.get(ns);
-    if (!nsEvents.has(event)) {
-      nsEvents.set(event, /* @__PURE__ */ new Set());
-    }
-    nsEvents.get(event).add(listener);
-    return () => {
-      var _a2;
-      nsEvents.get(event).delete(listener);
-      if (((_a2 = nsEvents.get(event)) == null ? void 0 : _a2.size) === 0) {
-        nsEvents.delete(event);
-      }
-      if (nsEvents.size === 0) {
-        this.listeners.delete(ns);
-      }
-    };
-  }
-  async emit(key, event) {
-    var _a, _b, _c;
-    if (!this.listeners.has(key)) {
-      return;
-    }
-    const events = this.listeners.get(key);
-    const preEvent = `pre:${event}`;
-    const postEvent = `post:${event}`;
-    (_a = this.logger) == null ? void 0 : _a.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) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
-    (_b = this.logger) == null ? void 0 : _b.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
-    const res = await Promise.allSettled(
-      [...events.get(event) ?? []].map((listener) => listener(event))
-    ).then((results) => {
-      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
-          result.reason
-        );
-        return result;
-      });
-      if (res2.length > 0) {
-        return Promise.reject(res2);
-      }
-      return results;
-    });
-    (_c = this.logger) == null ? void 0 : _c.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) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
-    return res;
-  }
-};
-
-// packages/di/src/service-locator-instance-holder.mts
-var ServiceLocatorInstanceHolderKind = /* @__PURE__ */ ((ServiceLocatorInstanceHolderKind2) => {
-  ServiceLocatorInstanceHolderKind2["Instance"] = "instance";
-  ServiceLocatorInstanceHolderKind2["Factory"] = "factory";
-  ServiceLocatorInstanceHolderKind2["AbstractFactory"] = "abstractFactory";
-  return ServiceLocatorInstanceHolderKind2;
-})(ServiceLocatorInstanceHolderKind || {});
-var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
-  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
-  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
-  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
-  return ServiceLocatorInstanceHolderStatus2;
-})(ServiceLocatorInstanceHolderStatus || {});
-
-// packages/di/src/service-locator-manager.mts
-var ServiceLocatorManager = class {
-  constructor(logger = null) {
-    this.logger = logger;
-  }
-  instancesHolders = /* @__PURE__ */ new Map();
-  get(name) {
-    var _a, _b, _c;
-    const holder = this.instancesHolders.get(name);
-    if (holder) {
-      if (holder.ttl !== Infinity) {
-        const now = Date.now();
-        if (now - holder.createdAt > holder.ttl) {
-          (_a = this.logger) == null ? void 0 : _a.log(
-            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
-          );
-          return [new InstanceExpired(holder.name), holder];
-        }
-      } else if (holder.status === "destroying" /* Destroying */) {
-        (_b = this.logger) == null ? void 0 : _b.log(
-          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
-        );
-        return [new InstanceDestroying(holder.name), holder];
-      }
-      return [void 0, holder];
-    } else {
-      (_c = this.logger) == null ? void 0 : _c.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 (["InstanceExpired" /* InstanceExpired */, "InstanceDestroying" /* 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)
-      )
-    );
-  }
-};
-
-// packages/di/src/service-locator.mts
-var ServiceLocator = class {
-  constructor(registry = globalRegistry, logger = null) {
-    this.registry = registry;
-    this.logger = logger;
-    this.eventBus = new ServiceLocatorEventBus(logger);
-    this.manager = new ServiceLocatorManager(logger);
-  }
-  eventBus;
-  manager;
-  getEventBus() {
-    return this.eventBus;
-  }
-  storeInstance(instance, token, args) {
-    const instanceName = this.getInstanceIdentifier(token, args);
-    this.manager.set(instanceName, {
-      name: instanceName,
-      instance,
-      status: "created" /* Created */,
-      kind: "instance" /* 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) {
-    var _a, _b;
-    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 = (_a = token.schema) == null ? void 0 : _a.safeParse(realArgs);
-    if (validatedArgs && !validatedArgs.success) {
-      (_b = this.logger) == null ? void 0 : _b.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      return [new UnknownError(validatedArgs.error)];
-    }
-    return [void 0, validatedArgs == null ? 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) {
-    var _a, _b;
-    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 === "creating" /* Creating */) {
-        return holder.creationPromise;
-      } else if (holder.status === "destroying" /* Destroying */) {
-        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-      }
-      return [void 0, holder.instance];
-    }
-    switch (error.code) {
-      case "InstanceDestroying" /* InstanceDestroying */:
-        (_a = this.logger) == null ? void 0 : _a.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
-        );
-        await (holder == null ? void 0 : holder.destroyPromise);
-        return this.getInstance(token, args);
-      case "InstanceExpired" /* InstanceExpired */:
-        (_b = this.logger) == null ? void 0 : _b.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
-        );
-        await this.invalidate(instanceName);
-        return this.getInstance(token, args);
-      case "InstanceNotFound" /* 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") {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`
-    );
-    return this.eventBus.emit(name, event);
-  }
-  async createInstance(instanceName, token, args) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.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) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.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: "creating" /* Creating */,
-      kind: "abstractFactory" /* AbstractFactory */,
-      // @ts-expect-error TS2322 This is correct type
-      creationPromise: factory(ctx, args).then(async (instance) => {
-        var _a2;
-        holder.instance = instance;
-        holder.status = "created" /* Created */;
-        holder.deps = ctx.getDependencies();
-        holder.destroyListeners = ctx.getDestroyListeners();
-        holder.ttl = ctx.getTtl();
-        if (holder.deps.length > 0) {
-          (_a2 = this.logger) == null ? void 0 : _a2.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 === "Instance" /* Instance */) {
-          await this.invalidate(instanceName);
-        }
-        await this.notifyListeners(instanceName);
-        return [void 0, instance];
-      }).catch((error) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.error(
-          `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
-          error
-        );
-        return [new UnknownError(error)];
-      }),
-      effects: [],
-      deps: [],
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl: Infinity
-    };
-    if (scope === "Singleton" /* Singleton */) {
-      this.manager.set(instanceName, holder);
-    }
-    return holder.creationPromise;
-  }
-  createFactoryContext(instanceName) {
-    const dependencies = /* @__PURE__ */ new Set();
-    const destroyListeners = /* @__PURE__ */ 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 {
-      // @ts-expect-error This is correct type
-      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 instanceName2 = self.makeInstanceName(token, validatedArgs);
-          dependencies.add(instanceName2);
-          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) {
-    var _a, _b, _c, _d, _e;
-    (_a = this.logger) == null ? void 0 : _a.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 === "destroying" /* Destroying */) {
-        (_b = this.logger) == null ? void 0 : _b.trace(
-          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`
-        );
-        promises.push(holder.destroyPromise);
-        continue;
-      }
-      if (holder.status === "creating" /* Creating */) {
-        (_c = this.logger) == null ? void 0 : _c.trace(
-          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`
-        );
-        promises.push(
-          (_d = holder.creationPromise) == null ? void 0 : _d.then(() => {
-            var _a2;
-            if (round > 3) {
-              (_a2 = this.logger) == null ? void 0 : _a2.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 = "destroying" /* Destroying */;
-      (_e = this.logger) == null ? void 0 : _e.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]) => {
-        var _a;
-        if (holder.status === "creating" /* Creating */) {
-          return (_a = holder.creationPromise) == null ? void 0 : _a.then(() => null);
-        }
-        if (holder.status === "destroying" /* 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}`;
-  }
-};
-
-// packages/di/src/injector.mts
-var 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;
-}
-var values = getInjectors({
-  baseLocator: globalServiceLocator
-});
-var inject = values.inject;
-var syncInject = values.syncInject;
-var wrapSyncInit = values.wrapSyncInit;
-var provideServiceLocator = values.provideServiceLocator;
-export {
-  BoundInjectionToken,
-  ErrorsEnum,
-  EventEmitter,
-  FactoryInjectionToken,
-  FactoryNotFound,
-  FactoryTokenNotResolved,
-  Injectable,
-  InjectableScope,
-  InjectableTokenMeta,
-  InjectableType,
-  InjectionToken,
-  InjectorsBase,
-  InstanceDestroying,
-  InstanceExpired,
-  InstanceNotFound,
-  ProxyServiceLocator,
-  Registry,
-  ServiceLocator,
-  ServiceLocatorEventBus,
-  ServiceLocatorInstanceHolderKind,
-  ServiceLocatorInstanceHolderStatus,
-  ServiceLocatorManager,
-  UnknownError,
-  getGlobalServiceLocator,
-  getInjectableToken,
-  getInjectors,
-  globalRegistry,
-  inject,
-  makeProxyServiceLocator,
-  provideServiceLocator,
-  resolveService,
-  syncInject,
-  wrapSyncInit
-};