@venok/core 1.1.0 → 2.0.1-next.1

package/dist/injector/module/lazy/loader.js

@@ -0,0 +1,71 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/module/lazy/loader.ts
+import { ModuleRef } from "../../../injector/module/ref.js";
+import { SilentLogger } from "../../../helpers/silent.helper.js";
+
+class LazyModuleLoader {
+  dependenciesScanner;
+  instanceLoader;
+  moduleCompiler;
+  modulesContainer;
+  moduleOverrides;
+  constructor(dependenciesScanner, instanceLoader, moduleCompiler, modulesContainer, moduleOverrides) {
+    this.dependenciesScanner = dependenciesScanner;
+    this.instanceLoader = instanceLoader;
+    this.moduleCompiler = moduleCompiler;
+    this.modulesContainer = modulesContainer;
+    this.moduleOverrides = moduleOverrides;
+  }
+  async load(loaderFn, loadOpts) {
+    this.registerLoggerConfiguration(loadOpts);
+    const moduleClassOrDynamicDefinition = await loaderFn();
+    const moduleInstances = await this.dependenciesScanner.scanForModules({
+      moduleDefinition: moduleClassOrDynamicDefinition,
+      overrides: this.moduleOverrides,
+      lazy: true
+    });
+    if (moduleInstances.length === 0) {
+      const { token } = await this.moduleCompiler.compile(moduleClassOrDynamicDefinition);
+      const moduleInstance = this.modulesContainer.get(token);
+      return moduleInstance && this.getTargetModuleRef(moduleInstance);
+    }
+    const lazyModulesContainer = this.createLazyModulesContainer(moduleInstances);
+    await this.dependenciesScanner.scanModulesForDependencies(lazyModulesContainer);
+    await this.instanceLoader.createInstancesOfDependencies(lazyModulesContainer);
+    const [targetModule] = moduleInstances;
+    return this.getTargetModuleRef(targetModule);
+  }
+  registerLoggerConfiguration(loadOpts) {
+    if (loadOpts?.logger === false) {
+      this.instanceLoader.setLogger(new SilentLogger);
+    }
+  }
+  createLazyModulesContainer(moduleInstances) {
+    moduleInstances = Array.from(new Set(moduleInstances));
+    return new Map(moduleInstances.map((ref) => [ref.token, ref]));
+  }
+  getTargetModuleRef(moduleInstance) {
+    const moduleRefInstanceWrapper = moduleInstance.getProviderByKey(ModuleRef);
+    return moduleRefInstanceWrapper.instance;
+  }
+}
+export {
+  LazyModuleLoader
+};

package/dist/injector/module/module.js

@@ -0,0 +1,395 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/module/module.ts
+import { ENTRY_PROVIDER_WATERMARK } from "../../constants.js";
+import { getClassScope } from "../../injector/helpers/class-scope.helper.js";
+import { InstanceWrapper } from "../../injector/instance/wrapper.js";
+import { isDurable } from "../../injector/helpers/is-durable.helper.js";
+import { ModuleRef } from "../../injector/module/ref.js";
+import { PROVIDER_ID_KEY } from "../../injector/constants.js";
+import { createContextId } from "../../helpers/context-id-factory.helper.js";
+import { isFunction, isNull, isObject, isString, isSymbol, isUndefined } from "../../helpers/shared.helper.js";
+import { randomStringGenerator } from "../../helpers/random-string-generator.helper.js";
+import { UuidFactory } from "../../helpers/uuid.helper.js";
+import { RuntimeException } from "../../errors/exceptions/runtime.exception.js";
+import { ApplicationConfig } from "../../application/config.js";
+import { InvalidClassException } from "../../errors/exceptions/invalid-class.exception.js";
+import { UnknownExportException } from "../../errors/exceptions/unknown-export.exception.js";
+
+class Module {
+  _metatype;
+  container;
+  _id;
+  _imports = new Set;
+  _providers = new Map;
+  _injectables = new Map;
+  _entryProviderKeys = new Set;
+  _exports = new Set;
+  _distance = 0;
+  _initOnPreview = false;
+  _isGlobal = false;
+  _token;
+  constructor(_metatype, container) {
+    this._metatype = _metatype;
+    this.container = container;
+    this.addCoreProviders();
+    this._id = this.generateUuid();
+  }
+  get id() {
+    return this._id;
+  }
+  get token() {
+    return this._token;
+  }
+  set token(token) {
+    this._token = token;
+  }
+  get name() {
+    return this.metatype.name;
+  }
+  get isGlobal() {
+    return this._isGlobal;
+  }
+  set isGlobal(global) {
+    this._isGlobal = global;
+  }
+  get initOnPreview() {
+    return this._initOnPreview;
+  }
+  set initOnPreview(initOnPreview) {
+    this._initOnPreview = initOnPreview;
+  }
+  get providers() {
+    return this._providers;
+  }
+  get imports() {
+    return this._imports;
+  }
+  get injectables() {
+    return this._injectables;
+  }
+  get entryProviders() {
+    return Array.from(this._entryProviderKeys).map((token) => this.providers.get(token)).filter(Boolean);
+  }
+  get exports() {
+    return this._exports;
+  }
+  get instance() {
+    if (!this._providers.has(this._metatype)) {
+      throw new RuntimeException;
+    }
+    const module = this._providers.get(this._metatype);
+    return module.instance;
+  }
+  get metatype() {
+    return this._metatype;
+  }
+  get distance() {
+    return this._distance;
+  }
+  set distance(value) {
+    this._distance = value;
+  }
+  addCoreProviders() {
+    this.addModuleAsProvider();
+    this.addModuleRef();
+    this.addApplicationConfig();
+  }
+  addModuleRef() {
+    const moduleRef = this.createModuleReferenceType();
+    this._providers.set(ModuleRef, new InstanceWrapper({
+      token: ModuleRef,
+      name: ModuleRef.name,
+      metatype: ModuleRef,
+      isResolved: true,
+      instance: new moduleRef,
+      host: this
+    }));
+  }
+  addModuleAsProvider() {
+    this._providers.set(this._metatype, new InstanceWrapper({
+      token: this._metatype,
+      name: this._metatype.name,
+      metatype: this._metatype,
+      isResolved: false,
+      instance: null,
+      host: this
+    }));
+  }
+  addApplicationConfig() {
+    this._providers.set(ApplicationConfig, new InstanceWrapper({
+      token: ApplicationConfig,
+      name: ApplicationConfig.name,
+      isResolved: true,
+      instance: this.container.applicationConfig,
+      host: this
+    }));
+  }
+  addInjectable(injectable, enhancerSubtype, host) {
+    if (this.isCustomProvider(injectable)) {
+      return this.addCustomProvider(injectable, this._injectables, enhancerSubtype);
+    }
+    let instanceWrapper = this.injectables.get(injectable);
+    if (!instanceWrapper) {
+      instanceWrapper = new InstanceWrapper({
+        token: injectable,
+        name: injectable.name,
+        metatype: injectable,
+        instance: null,
+        isResolved: false,
+        scope: getClassScope(injectable),
+        durable: isDurable(injectable),
+        subtype: enhancerSubtype,
+        host: this
+      });
+      this._injectables.set(injectable, instanceWrapper);
+    }
+    if (host) {
+      const hostWrapper = this._providers.get(host);
+      hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
+    }
+    return instanceWrapper;
+  }
+  assignProviderUniqueId(provider) {
+    Object.defineProperty(provider, PROVIDER_ID_KEY, {
+      enumerable: false,
+      writable: false,
+      configurable: true,
+      value: randomStringGenerator()
+    });
+  }
+  addProvider(provider, enhancerSubtype) {
+    if (this.isCustomProvider(provider)) {
+      if (this.isEntryProvider(provider.provide)) {
+        this._entryProviderKeys.add(provider.provide);
+      }
+      return this.addCustomProvider(provider, this._providers, enhancerSubtype);
+    }
+    this._providers.set(provider, new InstanceWrapper({
+      token: provider,
+      name: provider.name,
+      metatype: provider,
+      instance: null,
+      isResolved: false,
+      scope: getClassScope(provider),
+      durable: isDurable(provider),
+      host: this
+    }));
+    this.assignProviderUniqueId(provider);
+    if (this.isEntryProvider(provider)) {
+      this._entryProviderKeys.add(provider);
+    }
+    return provider;
+  }
+  isCustomProvider(provider) {
+    return !isNull(provider.provide);
+  }
+  addCustomProvider(provider, collection, enhancerSubtype) {
+    if (this.isCustomClass(provider)) {
+      this.addCustomClass(provider, collection, enhancerSubtype);
+    } else if (this.isCustomValue(provider)) {
+      this.addCustomValue(provider, collection, enhancerSubtype);
+    } else if (this.isCustomFactory(provider)) {
+      this.addCustomFactory(provider, collection, enhancerSubtype);
+    } else if (this.isCustomUseExisting(provider)) {
+      this.addCustomUseExisting(provider, collection, enhancerSubtype);
+    }
+    return provider.provide;
+  }
+  isCustomClass(provider) {
+    return !isUndefined(provider.useClass);
+  }
+  isCustomValue(provider) {
+    return isObject(provider) && Object.prototype.hasOwnProperty.call(provider, "useValue");
+  }
+  isCustomFactory(provider) {
+    return !isUndefined(provider.useFactory);
+  }
+  isCustomUseExisting(provider) {
+    return !isUndefined(provider.useExisting);
+  }
+  isDynamicModule(exported) {
+    return exported && exported.module;
+  }
+  addCustomClass(provider, collection, enhancerSubtype) {
+    let { scope, durable } = provider;
+    const { useClass } = provider;
+    if (isUndefined(scope)) {
+      scope = getClassScope(useClass);
+    }
+    if (isUndefined(durable)) {
+      durable = isDurable(useClass);
+    }
+    const token = provider.provide;
+    collection.set(token, new InstanceWrapper({
+      token,
+      name: useClass?.name ?? useClass,
+      metatype: useClass,
+      instance: null,
+      isResolved: false,
+      scope,
+      durable,
+      host: this,
+      subtype: enhancerSubtype
+    }));
+    this.assignProviderUniqueId(useClass);
+  }
+  addCustomValue(provider, collection, enhancerSubtype) {
+    const { useValue: value, provide: providerToken } = provider;
+    collection.set(providerToken, new InstanceWrapper({
+      token: providerToken,
+      name: providerToken?.name ?? providerToken,
+      metatype: null,
+      instance: value,
+      isResolved: true,
+      async: value instanceof Promise,
+      host: this,
+      subtype: enhancerSubtype
+    }));
+    this.assignProviderUniqueId(value);
+  }
+  addCustomFactory(provider, collection, enhancerSubtype) {
+    const { useFactory: factory, inject, scope, durable, provide: providerToken } = provider;
+    collection.set(providerToken, new InstanceWrapper({
+      token: providerToken,
+      name: providerToken?.name ?? providerToken,
+      metatype: factory,
+      instance: null,
+      isResolved: false,
+      inject: inject || [],
+      scope,
+      durable,
+      host: this,
+      subtype: enhancerSubtype
+    }));
+  }
+  addCustomUseExisting(provider, collection, enhancerSubtype) {
+    const { useExisting, provide: providerToken } = provider;
+    collection.set(providerToken, new InstanceWrapper({
+      token: providerToken,
+      name: providerToken?.name ?? providerToken,
+      metatype: (instance) => instance,
+      instance: null,
+      isResolved: false,
+      inject: [useExisting],
+      host: this,
+      isAlias: true,
+      subtype: enhancerSubtype
+    }));
+  }
+  addExportedProviderOrModule(toExport) {
+    const addExportedUnit = (token) => this._exports.add(this.validateExportedProvider(token));
+    if (this.isCustomProvider(toExport)) {
+      return this.addCustomExportedProvider(toExport);
+    } else if (isString(toExport) || isSymbol(toExport)) {
+      return addExportedUnit(toExport);
+    } else if (this.isDynamicModule(toExport)) {
+      const { module: moduleClassRef } = toExport;
+      return addExportedUnit(moduleClassRef);
+    }
+    addExportedUnit(toExport);
+  }
+  addCustomExportedProvider(provider) {
+    const provide = provider.provide;
+    if (isString(provide) || isSymbol(provide)) {
+      return this._exports.add(this.validateExportedProvider(provide));
+    }
+    this._exports.add(this.validateExportedProvider(provide));
+  }
+  validateExportedProvider(token) {
+    if (this._providers.has(token)) {
+      return token;
+    }
+    const imports = Array.from(this._imports.values()).filter(Boolean).map(({ metatype }) => metatype).filter(Boolean);
+    if (!imports.includes(token)) {
+      const { name } = this.metatype;
+      const providerName = isFunction(token) ? token.name : token;
+      throw new UnknownExportException(providerName, name);
+    }
+    return token;
+  }
+  addImport(moduleRef) {
+    this._imports.add(moduleRef);
+  }
+  replace(toReplace, options) {
+    if (options.isProvider && this.hasProvider(toReplace)) {
+      const originalProvider = this._providers.get(toReplace);
+      return originalProvider.mergeWith({ provide: toReplace, ...options });
+    } else if (!options.isProvider && this.hasInjectable(toReplace)) {
+      const originalInjectable = this._injectables.get(toReplace);
+      return originalInjectable.mergeWith({ provide: toReplace, ...options });
+    }
+  }
+  hasProvider(token) {
+    return this._providers.has(token);
+  }
+  hasInjectable(token) {
+    return this._injectables.has(token);
+  }
+  getProviderByKey(name) {
+    return this._providers.get(name);
+  }
+  getProviderById(id) {
+    return Array.from(this._providers.values()).find((item) => item.id === id);
+  }
+  getInjectableById(id) {
+    return Array.from(this._injectables.values()).find((item) => item.id === id);
+  }
+  getNonAliasProviders() {
+    return [...this._providers].filter(([, wrapper]) => !wrapper.isAlias);
+  }
+  createModuleReferenceType() {
+    const self = this;
+    return class extends ModuleRef {
+      constructor() {
+        super(self.container);
+      }
+      get(typeOrToken, options = {}) {
+        options.strict ??= true;
+        options.each ??= false;
+        return this.find(typeOrToken, options.strict ? {
+          moduleId: self.id,
+          each: options.each
+        } : options);
+      }
+      resolve(typeOrToken, contextId = createContextId(), options = {}) {
+        options.strict ??= true;
+        options.each ??= false;
+        return this.resolvePerContext(typeOrToken, self, contextId, options);
+      }
+      async create(type, contextId) {
+        if (!(type && isFunction(type) && type.prototype)) {
+          throw new InvalidClassException(type);
+        }
+        return this.instantiateClass(type, self, contextId);
+      }
+    };
+  }
+  isEntryProvider(metatype) {
+    return typeof metatype === "function" ? !!Reflect.getMetadata(ENTRY_PROVIDER_WATERMARK, metatype) : false;
+  }
+  generateUuid() {
+    const prefix = "M_";
+    const key = this.name?.toString() ?? this.token?.toString();
+    return key ? UuidFactory.get(`${prefix}_${key}`) : randomStringGenerator();
+  }
+}
+export {
+  Module
+};

package/dist/injector/module/ref.js

@@ -0,0 +1,78 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/module/ref.ts
+import { AbstractInstanceResolver } from "../../injector/instance/resolver.js";
+import { InstanceLinksHost } from "../../injector/instance/links-host.js";
+import { InstanceWrapper } from "../../injector/instance/wrapper.js";
+import { getClassScope } from "../../injector/helpers/class-scope.helper.js";
+import { Injector } from "../../injector/injector.js";
+import { isDurable } from "../../injector/helpers/is-durable.helper.js";
+import { Scope } from "../../enums/scope.enum.js";
+
+class ModuleRef extends AbstractInstanceResolver {
+  container;
+  injector = new Injector;
+  _instanceLinksHost;
+  get instanceLinksHost() {
+    if (!this._instanceLinksHost) {
+      this._instanceLinksHost = new InstanceLinksHost(this.container);
+    }
+    return this._instanceLinksHost;
+  }
+  constructor(container) {
+    super();
+    this.container = container;
+  }
+  introspect(token) {
+    const { wrapperRef } = this.instanceLinksHost.get(token);
+    let scope = Scope.DEFAULT;
+    if (!wrapperRef.isDependencyTreeStatic()) {
+      scope = Scope.REQUEST;
+    } else if (wrapperRef.isTransient) {
+      scope = Scope.TRANSIENT;
+    }
+    return { scope };
+  }
+  async instantiateClass(type, moduleRef, contextId) {
+    const wrapper = new InstanceWrapper({
+      name: type && type.name,
+      metatype: type,
+      isResolved: false,
+      scope: getClassScope(type),
+      durable: isDurable(type),
+      host: moduleRef
+    });
+    return new Promise(async (resolve, reject) => {
+      try {
+        const callback = async (instances) => {
+          const properties = await this.injector.resolveProperties(wrapper, moduleRef, undefined, contextId);
+          const instance = new type(...instances);
+          this.injector.applyProperties(instance, properties);
+          resolve(instance);
+        };
+        await this.injector.resolveConstructorParams(wrapper, moduleRef, null, callback, contextId);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+}
+export {
+  ModuleRef
+};

package/dist/injector/module/token-factory.js

@@ -0,0 +1,82 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/module/token-factory.ts
+import stringify from "fast-safe-stringify";
+import { createHash } from "crypto";
+import { isFunction, isSymbol } from "../../helpers/shared.helper.js";
+import { randomStringGenerator } from "../../helpers/random-string-generator.helper.js";
+var CLASS_STR = "class ";
+var CLASS_STR_LEN = CLASS_STR.length;
+
+class TokenFactory {
+  moduleTokenCache = new Map;
+  moduleIdsCache = new WeakMap;
+  create(metatype, dynamicModuleMetadata) {
+    const moduleId = this.getModuleId(metatype);
+    if (!dynamicModuleMetadata)
+      return this.getStaticModuleToken(moduleId, this.getModuleName(metatype));
+    const opaqueToken = {
+      id: moduleId,
+      module: this.getModuleName(metatype),
+      dynamic: dynamicModuleMetadata
+    };
+    const opaqueTokenString = this.getStringifiedOpaqueToken(opaqueToken);
+    return this.hashString(opaqueTokenString);
+  }
+  getStaticModuleToken(moduleId, moduleName) {
+    const key = `${moduleId}_${moduleName}`;
+    if (this.moduleTokenCache.has(key))
+      return this.moduleTokenCache.get(key);
+    const hash = this.hashString(key);
+    this.moduleTokenCache.set(key, hash);
+    return hash;
+  }
+  getStringifiedOpaqueToken(opaqueToken) {
+    return opaqueToken ? stringify(opaqueToken, this.replacer) : "";
+  }
+  getModuleId(metatype) {
+    let moduleId = this.moduleIdsCache.get(metatype);
+    if (moduleId)
+      return moduleId;
+    moduleId = randomStringGenerator();
+    this.moduleIdsCache.set(metatype, moduleId);
+    return moduleId;
+  }
+  getModuleName(metatype) {
+    return metatype.name;
+  }
+  hashString(value) {
+    return createHash("sha256").update(value).digest("hex");
+  }
+  replacer(key, value) {
+    if (isFunction(value)) {
+      const funcAsString = value.toString();
+      const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
+      if (isClass)
+        return value.name;
+      return funcAsString;
+    }
+    if (isSymbol(value))
+      return value.toString();
+    return value;
+  }
+}
+export {
+  TokenFactory
+};

package/dist/injector/settlement-signal.js

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/injector/settlement-signal.ts
+class SettlementSignal {
+  _refs = new Set;
+  settledPromise;
+  settleFn;
+  completed = false;
+  constructor() {
+    this.settledPromise = new Promise((resolve) => {
+      this.settleFn = resolve;
+    });
+  }
+  complete() {
+    this.completed = true;
+    this.settleFn();
+  }
+  error(err) {
+    this.completed = true;
+    this.settleFn(err);
+  }
+  asPromise() {
+    return this.settledPromise;
+  }
+  insertRef(wrapperId) {
+    this._refs.add(wrapperId);
+  }
+  isCycle(wrapperId) {
+    return !this.completed && this._refs.has(wrapperId);
+  }
+}
+export {
+  SettlementSignal
+};