@navios/di 0.1.0

package/dist/index.mjs

@@ -0,0 +1,960 @@
+// packages/di/src/decorators/injectable.decorator.mts
+import { NaviosException as NaviosException2 } from "@navios/common";
+
+// 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/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
+var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
+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) => resolveService(ctx, target),
+        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 { inject, syncInject, wrapSyncInit, provideServiceLocator } = getInjectors({
+  baseLocator: globalServiceLocator
+});
+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
+};