@venok/core 1.0.1-canary.5 → 2.0.0

package/dist/injector/instance/resolver.js

@@ -0,0 +1,61 @@
+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/instance/resolver.ts
+import { InvalidClassScopeException } from "../../errors/exceptions/invalid-class-scope.exception.js";
+import { UnknownElementException } from "../../errors/exceptions/unknown-element.exception.js";
+import { Scope } from "../../enums/scope.enum.js";
+
+class AbstractInstanceResolver {
+  find(typeOrToken, options) {
+    const instanceLinkOrArray = this.instanceLinksHost.get(typeOrToken, options);
+    const pluckInstance = ({ wrapperRef }) => {
+      if (wrapperRef.scope === Scope.REQUEST || wrapperRef.scope === Scope.TRANSIENT)
+        throw new InvalidClassScopeException(typeOrToken);
+      return wrapperRef.instance;
+    };
+    if (Array.isArray(instanceLinkOrArray))
+      return instanceLinkOrArray.map(pluckInstance);
+    return pluckInstance(instanceLinkOrArray);
+  }
+  async resolvePerContext(typeOrToken, contextModule, contextId, options) {
+    const instanceLinkOrArray = options?.strict ? this.instanceLinksHost.get(typeOrToken, {
+      moduleId: contextModule.id,
+      each: options.each
+    }) : this.instanceLinksHost.get(typeOrToken, {
+      each: options?.each ? options.each : false
+    });
+    const pluckInstance = async (instanceLink) => {
+      const { wrapperRef, collection } = instanceLink;
+      if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient)
+        return this.get(typeOrToken, { strict: options?.strict });
+      const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
+      const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);
+      if (!instance)
+        throw new UnknownElementException;
+      return instance;
+    };
+    if (Array.isArray(instanceLinkOrArray)) {
+      return Promise.all(instanceLinkOrArray.map((instanceLink) => pluckInstance(instanceLink)));
+    }
+    return pluckInstance(instanceLinkOrArray);
+  }
+}
+export {
+  AbstractInstanceResolver
+};

package/dist/injector/instance/wrapper.js

@@ -0,0 +1,324 @@
+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/instance/wrapper.ts
+import { isClassProvider, isFactoryProvider, isValueProvider } from "../../injector/helpers/classifier.helper.js";
+import { STATIC_CONTEXT } from "../../injector/constants.js";
+import { colors } from "../../helpers/color.helper.js";
+import { isNull, isString, isUndefined } from "../../helpers/shared.helper.js";
+import { randomStringGenerator } from "../../helpers/random-string-generator.helper.js";
+import { UuidFactory } from "../../helpers/uuid.helper.js";
+import { Logger } from "../../services/logger.service.js";
+import { Scope } from "../../enums/scope.enum.js";
+var INSTANCE_METADATA_SYMBOL = Symbol.for("instance_metadata:cache");
+var INSTANCE_ID_SYMBOL = Symbol.for("instance_metadata:id");
+
+class InstanceWrapper {
+  isAlias = false;
+  scope = Scope.DEFAULT;
+  name;
+  token;
+  async;
+  host;
+  subtype;
+  metatype;
+  inject;
+  forwardRef;
+  durable;
+  initTime;
+  settlementSignal;
+  static logger = new Logger(InstanceWrapper.name);
+  values = new WeakMap;
+  [INSTANCE_METADATA_SYMBOL] = {};
+  [INSTANCE_ID_SYMBOL];
+  transientMap = new Map;
+  isTreeStatic;
+  isTreeDurable;
+  rootInquirer;
+  constructor(metadata = {}) {
+    this.initialize(metadata);
+    this[INSTANCE_ID_SYMBOL] = metadata[INSTANCE_ID_SYMBOL] ?? this.generateUuid();
+  }
+  get id() {
+    return this[INSTANCE_ID_SYMBOL];
+  }
+  set instance(value) {
+    this.values.set(STATIC_CONTEXT, { instance: value });
+  }
+  get instance() {
+    const instancePerContext = this.getInstanceByContextId(STATIC_CONTEXT);
+    return instancePerContext.instance;
+  }
+  get isNotMetatype() {
+    return !this.metatype || this.isFactory;
+  }
+  get isFactory() {
+    return !!(this.metatype && !isNull(this.inject));
+  }
+  get isTransient() {
+    return this.scope === Scope.TRANSIENT;
+  }
+  getInstanceByContextId(contextId, inquirerId) {
+    if (this.scope === Scope.TRANSIENT && inquirerId) {
+      return this.getInstanceByInquirerId(contextId, inquirerId);
+    }
+    const instancePerContext = this.values.get(contextId);
+    return instancePerContext ? instancePerContext : contextId !== STATIC_CONTEXT ? this.cloneStaticInstance(contextId) : {
+      instance: null,
+      isResolved: true,
+      isPending: false
+    };
+  }
+  getInstanceByInquirerId(contextId, inquirerId) {
+    let collectionPerContext = this.transientMap.get(inquirerId);
+    if (!collectionPerContext) {
+      collectionPerContext = new WeakMap;
+      this.transientMap.set(inquirerId, collectionPerContext);
+    }
+    const instancePerContext = collectionPerContext.get(contextId);
+    return instancePerContext ? instancePerContext : this.cloneTransientInstance(contextId, inquirerId);
+  }
+  setInstanceByContextId(contextId, value, inquirerId) {
+    if (this.scope === Scope.TRANSIENT && inquirerId) {
+      return this.setInstanceByInquirerId(contextId, inquirerId, value);
+    }
+    this.values.set(contextId, value);
+  }
+  setInstanceByInquirerId(contextId, inquirerId, value) {
+    let collection = this.transientMap.get(inquirerId);
+    if (!collection) {
+      collection = new WeakMap;
+      this.transientMap.set(inquirerId, collection);
+    }
+    collection.set(contextId, value);
+  }
+  removeInstanceByContextId(contextId, inquirerId) {
+    if (this.scope === Scope.TRANSIENT && inquirerId) {
+      return this.removeInstanceByInquirerId(contextId, inquirerId);
+    }
+    this.values.delete(contextId);
+  }
+  removeInstanceByInquirerId(contextId, inquirerId) {
+    const collection = this.transientMap.get(inquirerId);
+    if (!collection)
+      return;
+    collection.delete(contextId);
+  }
+  addCtorMetadata(index, wrapper) {
+    if (!this[INSTANCE_METADATA_SYMBOL].dependencies) {
+      this[INSTANCE_METADATA_SYMBOL].dependencies = [];
+    }
+    this[INSTANCE_METADATA_SYMBOL].dependencies[index] = wrapper;
+  }
+  getCtorMetadata() {
+    return this[INSTANCE_METADATA_SYMBOL].dependencies ?? [];
+  }
+  addPropertiesMetadata(key, wrapper) {
+    if (!this[INSTANCE_METADATA_SYMBOL].properties) {
+      this[INSTANCE_METADATA_SYMBOL].properties = [];
+    }
+    this[INSTANCE_METADATA_SYMBOL].properties.push({
+      key,
+      wrapper
+    });
+  }
+  getPropertiesMetadata() {
+    return this[INSTANCE_METADATA_SYMBOL].properties ?? [];
+  }
+  addEnhancerMetadata(wrapper) {
+    if (!this[INSTANCE_METADATA_SYMBOL].enhancers) {
+      this[INSTANCE_METADATA_SYMBOL].enhancers = [];
+    }
+    this[INSTANCE_METADATA_SYMBOL].enhancers.push(wrapper);
+  }
+  getEnhancersMetadata() {
+    return this[INSTANCE_METADATA_SYMBOL].enhancers ?? [];
+  }
+  isDependencyTreeDurable(lookupRegistry = []) {
+    if (!isUndefined(this.isTreeDurable)) {
+      return this.isTreeDurable;
+    }
+    if (this.scope === Scope.REQUEST) {
+      this.isTreeDurable = this.durable === undefined ? false : this.durable;
+      if (this.isTreeDurable) {
+        this.printIntrospectedAsDurable();
+      }
+      return this.isTreeDurable;
+    }
+    const isStatic = this.isDependencyTreeStatic();
+    if (isStatic)
+      return false;
+    const isTreeNonDurable = this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic() && !item.isDependencyTreeDurable(registry)), lookupRegistry);
+    this.isTreeDurable = !isTreeNonDurable;
+    if (this.isTreeDurable)
+      this.printIntrospectedAsDurable();
+    return this.isTreeDurable;
+  }
+  introspectDepsAttribute(callback, lookupRegistry = []) {
+    if (lookupRegistry.includes(this[INSTANCE_ID_SYMBOL])) {
+      return false;
+    }
+    lookupRegistry = lookupRegistry.concat(this[INSTANCE_ID_SYMBOL]);
+    const { dependencies, properties, enhancers } = this[INSTANCE_METADATA_SYMBOL];
+    let introspectionResult = dependencies ? callback(dependencies, lookupRegistry) : false;
+    if (introspectionResult || !(properties || enhancers))
+      return introspectionResult;
+    introspectionResult = properties ? callback(properties.map((item) => item.wrapper), lookupRegistry) : false;
+    if (introspectionResult || !enhancers)
+      return introspectionResult;
+    return enhancers ? callback(enhancers, lookupRegistry) : false;
+  }
+  isDependencyTreeStatic(lookupRegistry = []) {
+    if (!isUndefined(this.isTreeStatic))
+      return this.isTreeStatic;
+    if (this.scope === Scope.REQUEST) {
+      this.isTreeStatic = false;
+      this.printIntrospectedAsRequestScoped();
+      return this.isTreeStatic;
+    }
+    this.isTreeStatic = !this.introspectDepsAttribute((collection, registry) => collection.some((item) => !item.isDependencyTreeStatic(registry)), lookupRegistry);
+    if (!this.isTreeStatic)
+      this.printIntrospectedAsRequestScoped();
+    return this.isTreeStatic;
+  }
+  cloneStaticInstance(contextId) {
+    const staticInstance = this.getInstanceByContextId(STATIC_CONTEXT);
+    if (this.isDependencyTreeStatic())
+      return staticInstance;
+    const instancePerContext = {
+      ...staticInstance,
+      instance: undefined,
+      isResolved: false,
+      isPending: false
+    };
+    if (this.isNewable())
+      instancePerContext.instance = Object.create(this.metatype.prototype);
+    this.setInstanceByContextId(contextId, instancePerContext);
+    return instancePerContext;
+  }
+  cloneTransientInstance(contextId, inquirerId) {
+    const staticInstance = this.getInstanceByContextId(STATIC_CONTEXT);
+    const instancePerContext = {
+      ...staticInstance,
+      instance: undefined,
+      isResolved: false,
+      isPending: false
+    };
+    if (this.isNewable()) {
+      instancePerContext.instance = Object.create(this.metatype.prototype);
+    }
+    this.setInstanceByInquirerId(contextId, inquirerId, instancePerContext);
+    return instancePerContext;
+  }
+  createPrototype(contextId) {
+    const host = this.getInstanceByContextId(contextId);
+    if (!this.isNewable() || host.isResolved)
+      return;
+    return Object.create(this.metatype.prototype);
+  }
+  isInRequestScope(contextId, inquirer) {
+    const isDependencyTreeStatic = this.isDependencyTreeStatic();
+    return !isDependencyTreeStatic && contextId !== STATIC_CONTEXT && (!this.isTransient || this.isTransient && !!inquirer);
+  }
+  isLazyTransient(contextId, inquirer) {
+    const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
+    return this.isDependencyTreeStatic() && contextId !== STATIC_CONTEXT && this.isTransient && !!isInquirerRequestScoped;
+  }
+  isExplicitlyRequested(contextId, inquirer) {
+    const isSelfRequested = inquirer === this;
+    return this.isDependencyTreeStatic() && contextId !== STATIC_CONTEXT && !!(isSelfRequested || inquirer && inquirer.scope === Scope.TRANSIENT);
+  }
+  isStatic(contextId, inquirer) {
+    const isInquirerRequestScoped = inquirer && !inquirer.isDependencyTreeStatic();
+    const isStaticTransient = this.isTransient && !isInquirerRequestScoped;
+    const rootInquirer = inquirer?.getRootInquirer();
+    return this.isDependencyTreeStatic() && contextId === STATIC_CONTEXT && (!this.isTransient || isStaticTransient && !!inquirer && !inquirer.isTransient || isStaticTransient && !!rootInquirer && !rootInquirer.isTransient);
+  }
+  attachRootInquirer(inquirer) {
+    if (!this.isTransient)
+      return;
+    this.rootInquirer = inquirer.getRootInquirer() ?? inquirer;
+  }
+  getRootInquirer() {
+    return this.rootInquirer;
+  }
+  getStaticTransientInstances() {
+    if (!this.transientMap)
+      return [];
+    const instances = [...this.transientMap.values()];
+    return instances.map((item) => item.get(STATIC_CONTEXT)).filter((item) => {
+      return !!(item && item.isConstructorCalled);
+    });
+  }
+  mergeWith(provider) {
+    if (isValueProvider(provider)) {
+      this.metatype = null;
+      this.inject = null;
+      this.scope = Scope.DEFAULT;
+      this.setInstanceByContextId(STATIC_CONTEXT, {
+        instance: provider.useValue,
+        isResolved: true,
+        isPending: false
+      });
+    } else if (isClassProvider(provider)) {
+      this.inject = null;
+      this.metatype = provider.useClass;
+    } else if (isFactoryProvider(provider)) {
+      this.metatype = provider.useFactory;
+      this.inject = provider.inject || [];
+    }
+  }
+  isNewable() {
+    return isNull(this.inject) && this.metatype && this.metatype.prototype;
+  }
+  initialize(metadata) {
+    const { instance, isResolved, ...wrapperPartial } = metadata;
+    Object.assign(this, wrapperPartial);
+    this.setInstanceByContextId(STATIC_CONTEXT, { instance, isResolved });
+    this.scope === Scope.TRANSIENT && (this.transientMap = new Map);
+  }
+  printIntrospectedAsRequestScoped() {
+    if (!this.isDebugMode() || this.name === "REQUEST") {
+      return;
+    }
+    if (isString(this.name)) {
+      InstanceWrapper.logger.log(`${colors.cyanBright(this.name)}${colors.green(" introspected as ")}${colors.magentaBright("request-scoped")}`);
+    }
+  }
+  printIntrospectedAsDurable() {
+    if (!this.isDebugMode()) {
+      return;
+    }
+    if (isString(this.name)) {
+      InstanceWrapper.logger.log(`${colors.cyanBright(this.name)}${colors.green(" introspected as ")}${colors.magentaBright("durable")}`);
+    }
+  }
+  isDebugMode() {
+    return !!process.env.VENOK_DEBUG;
+  }
+  generateUuid() {
+    let key = this.name?.toString() ?? this.token?.toString();
+    key += this.host?.name ?? "";
+    return key ? UuidFactory.get(key) : randomStringGenerator();
+  }
+}
+export {
+  InstanceWrapper,
+  INSTANCE_METADATA_SYMBOL,
+  INSTANCE_ID_SYMBOL
+};

package/dist/injector/internal-core-module/core-providers.js

@@ -0,0 +1,42 @@
+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/internal-core-module/core-providers.ts
+import { INQUIRER, REQUEST } from "../../constants.js";
+import { Reflector } from "../../services/reflector.service.js";
+import { noop } from "../../helpers/noop.helper.js";
+import { Scope } from "../../enums/scope.enum.js";
+var ReflectorAliasProvider = {
+  provide: Reflector.name,
+  useExisting: Reflector
+};
+var requestProvider = {
+  provide: REQUEST,
+  scope: Scope.REQUEST,
+  useFactory: noop
+};
+var inquirerProvider = {
+  provide: INQUIRER,
+  scope: Scope.TRANSIENT,
+  useFactory: noop
+};
+export {
+  requestProvider,
+  inquirerProvider,
+  ReflectorAliasProvider
+};

package/dist/injector/internal-core-module/internal-core-module-factory.js

@@ -0,0 +1,66 @@
+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/internal-core-module/internal-core-module-factory.ts
+import { Injector } from "../../injector/injector.js";
+import { LazyModuleLoader } from "../../injector/module/lazy/loader.js";
+import { ModulesContainer } from "../../injector/module/container.js";
+import { VenokContainer } from "../../injector/container.js";
+import { InternalCoreModule } from "../../injector/internal-core-module/internal-core-module.js";
+import { InstanceLoader } from "../../injector/instance/loader.js";
+import { SerializedGraph } from "../../inspector/serialized-graph.js";
+import { VenokContextCreator } from "../../context/context.js";
+import { Logger } from "../../services/logger.service.js";
+
+class InternalCoreModuleFactory {
+  static create(container, scanner, moduleCompiler, graphInspector, moduleOverrides) {
+    const lazyModuleLoaderFactory = () => {
+      const logger = new Logger(LazyModuleLoader.name, {
+        timestamp: false
+      });
+      const injector = new Injector;
+      const instanceLoader = new InstanceLoader(container, injector, graphInspector, logger);
+      return new LazyModuleLoader(scanner, instanceLoader, moduleCompiler, container.getModules(), moduleOverrides);
+    };
+    return InternalCoreModule.register([
+      {
+        provide: VenokContainer,
+        useValue: container
+      },
+      {
+        provide: VenokContextCreator,
+        useValue: VenokContextCreator.fromContainer(container)
+      },
+      {
+        provide: ModulesContainer,
+        useValue: container.getModules()
+      },
+      {
+        provide: LazyModuleLoader,
+        useFactory: lazyModuleLoaderFactory
+      },
+      {
+        provide: SerializedGraph,
+        useValue: container.serializedGraph
+      }
+    ]);
+  }
+}
+export {
+  InternalCoreModuleFactory
+};

package/dist/injector/internal-core-module/internal-core-module.js

@@ -0,0 +1,46 @@
+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/internal-core-module/internal-core-module.ts
+import {
+  inquirerProvider,
+  ReflectorAliasProvider,
+  requestProvider
+} from "../../injector/internal-core-module/core-providers.js";
+import { Global } from "../../decorators/global.decorator.js";
+import { Module } from "../../decorators/module.decorator.js";
+import { Reflector } from "../../services/reflector.service.js";
+class InternalCoreModule {
+  static register(providers) {
+    return {
+      module: InternalCoreModule,
+      providers: [...providers],
+      exports: [...providers.map((item) => item.provide)]
+    };
+  }
+}
+InternalCoreModule = __legacyDecorateClassTS([
+  Global(),
+  Module({
+    providers: [Reflector, ReflectorAliasProvider, requestProvider, inquirerProvider],
+    exports: [Reflector, ReflectorAliasProvider, requestProvider, inquirerProvider]
+  })
+], InternalCoreModule);
+export {
+  InternalCoreModule
+};

package/dist/injector/module/compiler.js

@@ -0,0 +1,47 @@
+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/compiler.ts
+import { TokenFactory } from "../../injector/module/token-factory.js";
+
+class ModuleCompiler {
+  moduleTokenFactory;
+  constructor(moduleTokenFactory = new TokenFactory) {
+    this.moduleTokenFactory = moduleTokenFactory;
+  }
+  async compile(metatype) {
+    const { type, dynamicMetadata } = this.extractMetadata(await metatype);
+    const token = this.moduleTokenFactory.create(type, dynamicMetadata);
+    return { type, dynamicMetadata, token };
+  }
+  extractMetadata(metatype) {
+    if (!this.isDynamicModule(metatype)) {
+      return {
+        type: metatype?.forwardRef ? metatype.forwardRef() : metatype
+      };
+    }
+    const { module: type, ...dynamicMetadata } = metatype;
+    return { type, dynamicMetadata };
+  }
+  isDynamicModule(module) {
+    return !!module.module;
+  }
+}
+export {
+  ModuleCompiler
+};

package/dist/injector/module/container.js

@@ -0,0 +1,33 @@
+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/container.ts
+import { uid } from "uid";
+
+class ModulesContainer extends Map {
+  #applicationId = uid(21);
+  get applicationId() {
+    return this.#applicationId;
+  }
+  getById(id) {
+    return Array.from(this.values()).find((moduleRef) => moduleRef.id === id);
+  }
+}
+export {
+  ModulesContainer
+};