@venok/core 1.1.0 → 2.0.0

package/dist/injector/topology-tree/topology-tree.js

@@ -0,0 +1,68 @@
+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/topology-tree/topology-tree.ts
+import { TreeNode } from "../../injector/topology-tree/tree-node.js";
+
+class TopologyTree {
+  root;
+  links = new Map;
+  constructor(moduleRef) {
+    this.root = new TreeNode({
+      value: moduleRef,
+      parent: null
+    });
+    this.links.set(moduleRef, this.root);
+    this.traverseAndMapToTree(this.root);
+  }
+  walk(callback) {
+    function walkNode(node, depth = 1) {
+      callback(node.value, depth);
+      node.children.forEach((child) => walkNode(child, depth + 1));
+    }
+    walkNode(this.root);
+  }
+  traverseAndMapToTree(node, depth = 1) {
+    if (!node.value.imports)
+      return;
+    node.value.imports.forEach((child) => {
+      if (!child) {
+        return;
+      }
+      if (this.links.has(child)) {
+        const existingSubtree = this.links.get(child);
+        if (node.hasCycleWith(child))
+          return;
+        const existingDepth = existingSubtree.getDepth();
+        if (existingDepth < depth)
+          existingSubtree.relink(node);
+        return;
+      }
+      const childNode = new TreeNode({
+        value: child,
+        parent: node
+      });
+      node.addChild(childNode);
+      this.links.set(child, childNode);
+      this.traverseAndMapToTree(childNode, depth + 1);
+    });
+  }
+}
+export {
+  TopologyTree
+};

package/dist/injector/topology-tree/tree-node.js

@@ -0,0 +1,68 @@
+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/topology-tree/tree-node.ts
+class TreeNode {
+  value;
+  children = new Set;
+  parent;
+  constructor({ value, parent }) {
+    this.value = value;
+    this.parent = parent;
+  }
+  addChild(child) {
+    this.children.add(child);
+  }
+  removeChild(child) {
+    this.children.delete(child);
+  }
+  relink(parent) {
+    this.parent?.removeChild(this);
+    this.parent = parent;
+    this.parent.addChild(this);
+  }
+  getDepth() {
+    const visited = new Set;
+    let depth = 0;
+    let current = this;
+    while (current) {
+      depth++;
+      current = current.parent;
+      if (visited.has(current))
+        return -1;
+      visited.add(current);
+    }
+    return depth;
+  }
+  hasCycleWith(target) {
+    const visited = new Set;
+    let current = this;
+    while (current) {
+      if (current.value === target)
+        return true;
+      current = current.parent;
+      if (visited.has(current))
+        return false;
+      visited.add(current);
+    }
+    return false;
+  }
+}
+export {
+  TreeNode
+};

package/dist/inspector/graph-inspector.js

@@ -0,0 +1,182 @@
+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/inspector/graph-inspector.ts
+import { DeterministicUuidRegistry } from "../helpers/uuid.helper.js";
+import { UnknownDependenciesException } from "../errors/exceptions/unknown-dependencies.exception.js";
+import { PartialGraphHost } from "../inspector/partial-graph.host.js";
+
+class GraphInspector {
+  container;
+  graph;
+  enhancersMetadataCache = new Array;
+  constructor(container) {
+    this.container = container;
+    this.graph = container.serializedGraph;
+  }
+  inspectModules(modules = this.container.getModules()) {
+    for (const moduleRef of modules.values()) {
+      this.insertModuleNode(moduleRef);
+      this.insertClassNodes(moduleRef);
+      this.insertModuleToModuleEdges(moduleRef);
+    }
+    this.enhancersMetadataCache.forEach((entry) => this.insertEnhancerEdge(entry));
+    DeterministicUuidRegistry.clear();
+  }
+  registerPartial(error) {
+    this.graph.status = "partial";
+    if (error instanceof UnknownDependenciesException) {
+      this.graph.metadata = {
+        cause: {
+          type: "unknown-dependencies",
+          context: error.context,
+          moduleId: error.moduleRef?.id,
+          nodeId: error.metadata?.id
+        }
+      };
+    } else {
+      this.graph.metadata = {
+        cause: {
+          type: "unknown",
+          error
+        }
+      };
+    }
+    PartialGraphHost.register(this.graph);
+  }
+  inspectInstanceWrapper(source, moduleRef) {
+    const ctorMetadata = source.getCtorMetadata();
+    ctorMetadata?.forEach((target, index) => this.insertClassToClassEdge(source, target, moduleRef, index, "constructor"));
+    const propertiesMetadata = source.getPropertiesMetadata();
+    propertiesMetadata?.forEach(({ key, wrapper: target }) => this.insertClassToClassEdge(source, target, moduleRef, key, "property"));
+  }
+  insertEnhancerMetadataCache(entry) {
+    this.enhancersMetadataCache.push(entry);
+  }
+  insertOrphanedEnhancer(entry) {
+    this.graph.insertOrphanedEnhancer({
+      ...entry,
+      ref: entry.ref?.constructor?.name ?? "Object"
+    });
+  }
+  insertAttachedEnhancer(wrapper) {
+    const existingNode = this.graph.getNodeById(wrapper.id);
+    existingNode.metadata.global = true;
+    this.graph.insertAttachedEnhancer(existingNode.id);
+  }
+  insertEntrypointDefinition(definition, parentId) {
+    definition = {
+      ...definition,
+      id: `${definition.classNodeId}_${definition.methodName}`
+    };
+    this.graph.insertEntrypoint(definition, parentId);
+  }
+  insertClassNode(moduleRef, wrapper, type) {
+    this.graph.insertNode({
+      id: wrapper.id,
+      label: wrapper.name,
+      parent: moduleRef.id,
+      metadata: {
+        type,
+        internal: wrapper.metatype === moduleRef.metatype,
+        sourceModuleName: moduleRef.name,
+        durable: wrapper.isDependencyTreeDurable(),
+        static: wrapper.isDependencyTreeStatic(),
+        scope: wrapper.scope,
+        transient: wrapper.isTransient,
+        exported: moduleRef.exports.has(wrapper.token),
+        token: wrapper.token,
+        subtype: wrapper.subtype,
+        initTime: wrapper.initTime ?? 0
+      }
+    });
+  }
+  insertModuleNode(moduleRef) {
+    const dynamicMetadata = this.container.getDynamicMetadataByToken(moduleRef.token);
+    const node = {
+      id: moduleRef.id,
+      label: moduleRef.name,
+      metadata: {
+        type: "module",
+        global: moduleRef.isGlobal,
+        dynamic: !!dynamicMetadata,
+        internal: moduleRef.name === "InternalCoreModule"
+      }
+    };
+    this.graph.insertNode(node);
+  }
+  insertModuleToModuleEdges(moduleRef) {
+    for (const targetModuleRef of moduleRef.imports) {
+      this.graph.insertEdge({
+        source: moduleRef.id,
+        target: targetModuleRef.id,
+        metadata: {
+          type: "module-to-module",
+          sourceModuleName: moduleRef.name,
+          targetModuleName: targetModuleRef.name
+        }
+      });
+    }
+  }
+  insertEnhancerEdge(entry) {
+    const moduleRef = this.container.getModuleByKey(entry.moduleToken);
+    const sourceInstanceWrapper = moduleRef.providers.get(entry.classRef);
+    const existingSourceNode = this.graph.getNodeById(sourceInstanceWrapper.id);
+    const enhancers = existingSourceNode.metadata.enhancers ?? [];
+    if (entry.enhancerInstanceWrapper) {
+      this.insertClassToClassEdge(sourceInstanceWrapper, entry.enhancerInstanceWrapper, moduleRef, undefined, "decorator");
+      enhancers.push({
+        id: entry.enhancerInstanceWrapper.id,
+        methodKey: entry.methodKey,
+        subtype: entry.subtype
+      });
+    } else {
+      const name = entry.enhancerRef.constructor?.name ?? entry.enhancerRef.name;
+      enhancers.push({
+        name,
+        methodKey: entry.methodKey,
+        subtype: entry.subtype
+      });
+    }
+    existingSourceNode.metadata.enhancers = enhancers;
+  }
+  insertClassToClassEdge(source, target, moduleRef, keyOrIndex, injectionType) {
+    this.graph.insertEdge({
+      source: source.id,
+      target: target.id,
+      metadata: {
+        type: "class-to-class",
+        sourceModuleName: moduleRef.name,
+        sourceClassName: source.name,
+        targetClassName: target.name,
+        sourceClassToken: source.token,
+        targetClassToken: target.token,
+        targetModuleName: target.host?.name ?? "",
+        keyOrIndex,
+        injectionType
+      }
+    });
+  }
+  insertClassNodes(moduleRef) {
+    moduleRef.providers.forEach((value) => this.insertClassNode(moduleRef, value, "provider"));
+    moduleRef.injectables.forEach((value) => this.insertClassNode(moduleRef, value, "injectable"));
+  }
+}
+export {
+  GraphInspector
+};

package/dist/inspector/initialize-on-preview.allowlist.js

@@ -0,0 +1,31 @@
+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/inspector/initialize-on-preview.allowlist.ts
+class InitializeOnPreviewAllowlist {
+  static allowlist = new WeakMap;
+  static add(type) {
+    this.allowlist.set(type, true);
+  }
+  static has(type) {
+    return this.allowlist.has(type);
+  }
+}
+export {
+  InitializeOnPreviewAllowlist
+};

package/dist/inspector/noop-graph-inspector.js

@@ -0,0 +1,27 @@
+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/inspector/noop-graph-inspector.ts
+import { GraphInspector } from "../inspector/graph-inspector.js";
+import { noop } from "../helpers/noop.helper.js";
+var NoopGraphInspector = new Proxy(GraphInspector.prototype, {
+  get: () => noop
+});
+export {
+  NoopGraphInspector
+};

package/dist/inspector/partial-graph.host.js

@@ -0,0 +1,34 @@
+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/inspector/partial-graph.host.ts
+class PartialGraphHost {
+  static partialGraph;
+  static toJSON() {
+    return this.partialGraph?.toJSON();
+  }
+  static toString() {
+    return this.partialGraph?.toString();
+  }
+  static register(partialGraph) {
+    this.partialGraph = partialGraph;
+  }
+}
+export {
+  PartialGraphHost
+};

package/dist/inspector/serialized-graph.js

@@ -0,0 +1,128 @@
+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/inspector/serialized-graph.ts
+import { ApplicationConfig } from "../application/config.js";
+import { LazyModuleLoader } from "../injector/module/lazy/loader.js";
+import { ModuleRef } from "../injector/module/ref.js";
+import { ModulesContainer } from "../injector/module/container.js";
+import { INQUIRER, REQUEST } from "../constants.js";
+import { DeterministicUuidRegistry } from "../helpers/uuid.helper.js";
+
+class SerializedGraph {
+  nodes = new Map;
+  edges = new Map;
+  entrypoints = new Map;
+  extras = {
+    orphanedEnhancers: [],
+    attachedEnhancers: []
+  };
+  _status = "complete";
+  _metadata;
+  static INTERNAL_PROVIDERS = [
+    ApplicationConfig,
+    ModuleRef,
+    LazyModuleLoader,
+    ModulesContainer,
+    REQUEST,
+    INQUIRER
+  ];
+  set status(status) {
+    this._status = status;
+  }
+  set metadata(metadata) {
+    this._metadata = metadata;
+  }
+  insertNode(nodeDefinition) {
+    if (nodeDefinition.metadata.type === "provider" && SerializedGraph.INTERNAL_PROVIDERS.includes(nodeDefinition.metadata.token)) {
+      nodeDefinition.metadata = {
+        ...nodeDefinition.metadata,
+        internal: true
+      };
+    }
+    if (this.nodes.has(nodeDefinition.id)) {
+      return this.nodes.get(nodeDefinition.id);
+    }
+    this.nodes.set(nodeDefinition.id, nodeDefinition);
+    return nodeDefinition;
+  }
+  insertEdge(edgeDefinition) {
+    if (edgeDefinition.metadata.type === "class-to-class" && (SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.sourceClassToken) || SerializedGraph.INTERNAL_PROVIDERS.includes(edgeDefinition.metadata.targetClassToken))) {
+      edgeDefinition.metadata = {
+        ...edgeDefinition.metadata,
+        internal: true
+      };
+    }
+    const id = edgeDefinition.id ?? this.generateUuidByEdgeDefinition(edgeDefinition);
+    const edge = {
+      ...edgeDefinition,
+      id
+    };
+    this.edges.set(id, edge);
+    return edge;
+  }
+  insertEntrypoint(definition, parentId) {
+    if (this.entrypoints.has(parentId)) {
+      const existingCollection = this.entrypoints.get(parentId);
+      existingCollection.push(definition);
+    } else {
+      this.entrypoints.set(parentId, [definition]);
+    }
+  }
+  insertOrphanedEnhancer(entry) {
+    this.extras.orphanedEnhancers.push(entry);
+  }
+  insertAttachedEnhancer(nodeId) {
+    this.extras.attachedEnhancers.push({
+      nodeId
+    });
+  }
+  getNodeById(id) {
+    return this.nodes.get(id);
+  }
+  toJSON() {
+    const json = {
+      nodes: Object.fromEntries(this.nodes),
+      edges: Object.fromEntries(this.edges),
+      entrypoints: Object.fromEntries(this.entrypoints),
+      extras: this.extras
+    };
+    if (this._status) {
+      json["status"] = this._status;
+    }
+    if (this._metadata) {
+      json["metadata"] = this._metadata;
+    }
+    return json;
+  }
+  toString() {
+    const replacer = (key, value) => {
+      if (typeof value === "symbol") {
+        return value.toString();
+      }
+      return typeof value === "function" ? value.name ?? "Function" : value;
+    };
+    return JSON.stringify(this.toJSON(), replacer, 2);
+  }
+  generateUuidByEdgeDefinition(edgeDefinition) {
+    return DeterministicUuidRegistry.get(JSON.stringify(edgeDefinition));
+  }
+}
+export {
+  SerializedGraph
+};

package/dist/interceptors/consumer.js

@@ -0,0 +1,54 @@
+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/interceptors/consumer.ts
+import { defer, from, mergeAll, Observable, switchMap } from "rxjs";
+import { AsyncResource } from "node:async_hooks";
+import { ExecutionContextHost } from "../context/execution-host.js";
+import { isEmpty } from "../helpers/shared.helper.js";
+
+class InterceptorsConsumer {
+  async intercept(interceptors, args, instance, callback, next, type) {
+    if (isEmpty(interceptors))
+      return next();
+    const context = this.createContext(args, instance, callback);
+    context.setType(type);
+    const nextFn = async (i = 0) => {
+      if (i >= interceptors.length) {
+        return defer(AsyncResource.bind(() => this.transformDeferred(next)));
+      }
+      const handler = {
+        handle: () => defer(AsyncResource.bind(() => nextFn(i + 1))).pipe(mergeAll())
+      };
+      return interceptors[i].intercept(context, handler);
+    };
+    return defer(() => nextFn()).pipe(mergeAll());
+  }
+  createContext(args, instance, callback) {
+    return new ExecutionContextHost(args, instance.constructor, callback);
+  }
+  transformDeferred(next) {
+    return from(next()).pipe(switchMap((res) => {
+      const isDeferred = res instanceof Promise || res instanceof Observable;
+      return isDeferred ? res : Promise.resolve(res);
+    }));
+  }
+}
+export {
+  InterceptorsConsumer
+};

package/dist/interceptors/context-creator.js

@@ -0,0 +1,75 @@
+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/interceptors/context-creator.ts
+import { STATIC_CONTEXT } from "../injector/constants.js";
+import { ContextCreator } from "../context/creator.js";
+import { isEmpty, isFunction } from "../helpers/shared.helper.js";
+import { INTERCEPTORS_METADATA } from "../constants.js";
+
+class InterceptorsContextCreator extends ContextCreator {
+  container;
+  config;
+  moduleContext;
+  constructor(container, config) {
+    super();
+    this.container = container;
+    this.config = config;
+  }
+  create(instance, callback, module, contextId = STATIC_CONTEXT, inquirerId) {
+    this.moduleContext = module;
+    return this.createContext(instance, callback, INTERCEPTORS_METADATA, contextId, inquirerId);
+  }
+  createConcreteContext(metadata, contextId = STATIC_CONTEXT, inquirerId) {
+    if (isEmpty(metadata))
+      return [];
+    return metadata.filter((interceptor) => interceptor && (interceptor.name || interceptor.intercept)).map((interceptor) => this.getInterceptorInstance(interceptor, contextId, inquirerId)).filter((interceptor) => interceptor && isFunction(interceptor.intercept));
+  }
+  getInterceptorInstance(metatype, contextId = STATIC_CONTEXT, inquirerId) {
+    const isObject = metatype.intercept;
+    if (isObject)
+      return metatype;
+    const instanceWrapper = this.getInstanceByMetatype(metatype);
+    if (!instanceWrapper)
+      return null;
+    const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+    return instanceHost && instanceHost.instance;
+  }
+  getInstanceByMetatype(metatype) {
+    if (!this.moduleContext)
+      return;
+    const collection = this.container.getModules();
+    const moduleRef = collection.get(this.moduleContext);
+    if (!moduleRef)
+      return;
+    return moduleRef.injectables.get(metatype);
+  }
+  getGlobalMetadata(contextId = STATIC_CONTEXT, inquirerId) {
+    if (!this.config)
+      return [];
+    const globalInterceptors = this.config.getGlobalInterceptors();
+    if (contextId === STATIC_CONTEXT && !inquirerId)
+      return globalInterceptors;
+    const scopedInterceptorWrappers = this.config.getGlobalRequestInterceptors();
+    const scopedInterceptors = scopedInterceptorWrappers.map((wrapper) => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId)).filter((host) => !!host).map((host) => host.instance);
+    return globalInterceptors.concat(scopedInterceptors);
+  }
+}
+export {
+  InterceptorsContextCreator
+};