@venok/core 1.0.0

package/injector/module/ref.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleRef = void 0;
+const injector_1 = require("@venok/core/injector/injector");
+const interfaces_1 = require("@venok/core/interfaces");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+const resolver_1 = require("@venok/core/injector/instance/resolver");
+const links_host_1 = require("@venok/core/injector/instance/links-host");
+const class_scope_helper_1 = require("@venok/core/injector/helpers/class-scope.helper");
+const is_durable_helper_1 = require("@venok/core/injector/helpers/is-durable.helper");
+class ModuleRef extends resolver_1.AbstractInstanceResolver {
+    get instanceLinksHost() {
+        if (!this._instanceLinksHost) {
+            this._instanceLinksHost = new links_host_1.InstanceLinksHost(this.container);
+        }
+        return this._instanceLinksHost;
+    }
+    constructor(container) {
+        super();
+        this.container = container;
+        this.injector = new injector_1.Injector();
+    }
+    introspect(token) {
+        const { wrapperRef } = this.instanceLinksHost.get(token);
+        let scope = interfaces_1.Scope.DEFAULT;
+        if (!wrapperRef.isDependencyTreeStatic()) {
+            scope = interfaces_1.Scope.REQUEST;
+        }
+        else if (wrapperRef.isTransient) {
+            scope = interfaces_1.Scope.TRANSIENT;
+        }
+        return { scope };
+    }
+    // public registerRequestByContextId<T = any>(request: T, contextId: ContextId) {
+    //   this.container.registerRequestProvider(request, contextId);
+    // }
+    async instantiateClass(type, moduleRef, contextId) {
+        const wrapper = new wrapper_1.InstanceWrapper({
+            name: type && type.name,
+            metatype: type,
+            isResolved: false,
+            scope: (0, class_scope_helper_1.getClassScope)(type),
+            durable: (0, is_durable_helper_1.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);
+            }
+        });
+    }
+}
+exports.ModuleRef = ModuleRef;

package/injector/module/token-factory.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@venok/core/interfaces";
+import { DynamicModule } from "@venok/core/interfaces/modules";
+export declare class TokenFactory {
+    private readonly moduleTokenCache;
+    private readonly moduleIdsCache;
+    create(metatype: Type<unknown>, dynamicModuleMetadata?: Partial<DynamicModule> | undefined): string;
+    getStaticModuleToken(moduleId: string, moduleName: string): string;
+    getStringifiedOpaqueToken(opaqueToken: object | undefined): string;
+    getModuleId(metatype: Type<unknown>): string;
+    getModuleName(metatype: Type<any>): string;
+    private hashString;
+    private replacer;
+}

package/injector/module/token-factory.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenFactory = void 0;
+const crypto_1 = require("crypto");
+const fast_safe_stringify_1 = __importDefault(require("fast-safe-stringify"));
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const CLASS_STR = "class ";
+const CLASS_STR_LEN = CLASS_STR.length;
+class TokenFactory {
+    constructor() {
+        this.moduleTokenCache = new Map();
+        this.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) {
+        // Uses safeStringify instead of JSON.stringify to support circular dynamic modules
+        // The replacer function is also required in order to obtain real class names
+        // instead of the unified "Function" key
+        return opaqueToken ? (0, fast_safe_stringify_1.default)(opaqueToken, this.replacer) : "";
+    }
+    getModuleId(metatype) {
+        let moduleId = this.moduleIdsCache.get(metatype);
+        if (moduleId)
+            return moduleId;
+        moduleId = (0, random_string_generator_helper_1.randomStringGenerator)();
+        this.moduleIdsCache.set(metatype, moduleId);
+        return moduleId;
+    }
+    getModuleName(metatype) {
+        return metatype.name;
+    }
+    hashString(value) {
+        return (0, crypto_1.createHash)("sha256").update(value).digest("hex");
+    }
+    replacer(key, value) {
+        if ((0, shared_helper_1.isFunction)(value)) {
+            const funcAsString = value.toString();
+            const isClass = funcAsString.slice(0, CLASS_STR_LEN) === CLASS_STR;
+            if (isClass)
+                return value.name;
+            return funcAsString;
+        }
+        if ((0, shared_helper_1.isSymbol)(value))
+            return value.toString();
+        return value;
+    }
+}
+exports.TokenFactory = TokenFactory;

package/injector/settlement-signal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SettlementSignal is used to signal the resolution of a provider/instance.
+ * Calling `complete` or `error` will resolve the promise returned by `asPromise`.
+ * Can be used to detect circular dependencies.
+ */
+export declare class SettlementSignal {
+    private readonly _refs;
+    private readonly settledPromise;
+    private settleFn;
+    private completed;
+    constructor();
+    /**
+     * Resolves the promise returned by `asPromise`.
+     */
+    complete(): void;
+    /**
+     * Rejects the promise returned by `asPromise` with the given error.
+     * @param err Error to reject the promise returned by `asPromise` with.
+     */
+    error(err: unknown): void;
+    /**
+     * Returns a promise that will be resolved when `complete` or `error` is called.
+     * @returns Promise that will be resolved when `complete` or `error` is called.
+     */
+    asPromise(): Promise<unknown>;
+    /**
+     * Inserts a wrapper id that the host of this signal depends on.
+     * @param wrapperId Wrapper id to insert.
+     */
+    insertRef(wrapperId: string): void;
+    /**
+     * Check if relationship is circular.
+     * @param wrapperId Wrapper id to check.
+     * @returns True if relationship is circular, false otherwise.
+     */
+    isCycle(wrapperId: string): boolean;
+}

package/injector/settlement-signal.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettlementSignal = void 0;
+/**
+ * SettlementSignal is used to signal the resolution of a provider/instance.
+ * Calling `complete` or `error` will resolve the promise returned by `asPromise`.
+ * Can be used to detect circular dependencies.
+ */
+class SettlementSignal {
+    constructor() {
+        this._refs = new Set();
+        this.completed = false;
+        this.settledPromise = new Promise((resolve) => {
+            this.settleFn = resolve;
+        });
+    }
+    /**
+     * Resolves the promise returned by `asPromise`.
+     */
+    complete() {
+        this.completed = true;
+        this.settleFn();
+    }
+    /**
+     * Rejects the promise returned by `asPromise` with the given error.
+     * @param err Error to reject the promise returned by `asPromise` with.
+     */
+    error(err) {
+        this.completed = true;
+        this.settleFn(err);
+    }
+    /**
+     * Returns a promise that will be resolved when `complete` or `error` is called.
+     * @returns Promise that will be resolved when `complete` or `error` is called.
+     */
+    asPromise() {
+        return this.settledPromise;
+    }
+    /**
+     * Inserts a wrapper id that the host of this signal depends on.
+     * @param wrapperId Wrapper id to insert.
+     */
+    insertRef(wrapperId) {
+        this._refs.add(wrapperId);
+    }
+    /**
+     * Check if relationship is circular.
+     * @param wrapperId Wrapper id to check.
+     * @returns True if relationship is circular, false otherwise.
+     */
+    isCycle(wrapperId) {
+        return !this.completed && this._refs.has(wrapperId);
+    }
+}
+exports.SettlementSignal = SettlementSignal;

package/inspector/graph-inspector.d.ts

@@ -0,0 +1,26 @@
+import { VenokContainer } from "../injector/container";
+import { Module } from "../injector/module/module";
+import { EnhancerMetadataCacheEntry } from "./interfaces/enhancer-metadata-cache-entry.interface";
+import { Entrypoint } from "./interfaces/entrypoint.interface";
+import { OrphanedEnhancerDefinition } from "./interfaces/extras.interface";
+import { Node } from "./interfaces/node.interface";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+export declare class GraphInspector {
+    private readonly container;
+    private readonly graph;
+    private readonly enhancersMetadataCache;
+    constructor(container: VenokContainer);
+    inspectModules(modules?: Map<string, Module>): void;
+    registerPartial(error: unknown): void;
+    inspectInstanceWrapper<T = any>(source: InstanceWrapper<T>, moduleRef: Module): void;
+    insertEnhancerMetadataCache(entry: EnhancerMetadataCacheEntry): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(wrapper: InstanceWrapper): void;
+    insertEntrypointDefinition<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertClassNode(moduleRef: Module, wrapper: InstanceWrapper, type: Exclude<Node["metadata"]["type"], "module">): void;
+    private insertModuleNode;
+    private insertModuleToModuleEdges;
+    private insertEnhancerEdge;
+    private insertClassToClassEdge;
+    private insertClassNodes;
+}

package/inspector/graph-inspector.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInspector = void 0;
+const unknown_dependencies_exception_1 = require("../errors/exceptions/unknown-dependencies.exception");
+const partial_graph_host_1 = require("./partial-graph.host");
+const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
+class GraphInspector {
+    constructor(container) {
+        this.container = container;
+        this.enhancersMetadataCache = new Array();
+        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));
+        uuid_helper_1.DeterministicUuidRegistry.clear();
+    }
+    registerPartial(error) {
+        this.graph.status = "partial";
+        if (error instanceof unknown_dependencies_exception_1.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,
+                },
+            };
+        }
+        partial_graph_host_1.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"));
+    }
+}
+exports.GraphInspector = GraphInspector;

package/inspector/initialize-on-preview.allowlist.d.ts

@@ -0,0 +1,6 @@
+import { Type } from "@venok/core/interfaces";
+export declare class InitializeOnPreviewAllowlist {
+    private static readonly allowlist;
+    static add(type: Type): void;
+    static has(type: Type): boolean;
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializeOnPreviewAllowlist = void 0;
+class InitializeOnPreviewAllowlist {
+    static add(type) {
+        this.allowlist.set(type, true);
+    }
+    static has(type) {
+        return this.allowlist.has(type);
+    }
+}
+exports.InitializeOnPreviewAllowlist = InitializeOnPreviewAllowlist;
+InitializeOnPreviewAllowlist.allowlist = new WeakMap();

package/inspector/interfaces/edge.interface.d.ts

@@ -0,0 +1,28 @@
+import { InjectionToken } from "@venok/core/interfaces/modules";
+type CommonEdgeMetadata = {
+    sourceModuleName: string;
+    targetModuleName: string;
+};
+type ModuleToModuleEdgeMetadata = {
+    type: "module-to-module";
+} & CommonEdgeMetadata;
+type ClassToClassEdgeMetadata = {
+    type: "class-to-class";
+    sourceClassName: string;
+    targetClassName: string;
+    sourceClassToken: InjectionToken;
+    targetClassToken: InjectionToken;
+    injectionType: "constructor" | "property" | "decorator";
+    keyOrIndex?: string | number | symbol;
+    /**
+     * If true, indicates that this edge represents an internal providers connection
+     */
+    internal?: boolean;
+} & CommonEdgeMetadata;
+export interface Edge {
+    id: string;
+    source: string;
+    target: string;
+    metadata: ModuleToModuleEdgeMetadata | ClassToClassEdgeMetadata;
+}
+export {};

package/inspector/interfaces/edge.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/enhancer-metadata-cache-entry.interface.d.ts

@@ -0,0 +1,12 @@
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { EnhancerSubtype } from "@venok/core/constants";
+import { Type } from "@venok/core/interfaces";
+export interface EnhancerMetadataCacheEntry {
+    targetNodeId?: string;
+    moduleToken: string;
+    classRef: Type;
+    methodKey: string | undefined;
+    enhancerRef?: unknown;
+    enhancerInstanceWrapper?: InstanceWrapper;
+    subtype: EnhancerSubtype;
+}

package/inspector/interfaces/enhancer-metadata-cache-entry.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/entrypoint.interface.d.ts

@@ -0,0 +1,10 @@
+export type Entrypoint<T> = {
+    id?: string;
+    type: string;
+    methodName: string;
+    className: string;
+    classNodeId: string;
+    metadata: {
+        key: string;
+    } & T;
+};

package/inspector/interfaces/entrypoint.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/extras.interface.d.ts

@@ -0,0 +1,18 @@
+import { EnhancerSubtype } from "@venok/core/constants";
+/**
+ * Enhancers attached through APP_PIPE, APP_GUARD, APP_INTERCEPTOR, and APP_FILTER tokens.
+ */
+export interface AttachedEnhancerDefinition {
+    nodeId: string;
+}
+/**
+ * Enhancers registered through "app.useGlobalPipes()", "app.useGlobalGuards()", "app.useGlobalInterceptors()", and "app.useGlobalFilters()" methods.
+ */
+export interface OrphanedEnhancerDefinition {
+    subtype: EnhancerSubtype;
+    ref: unknown;
+}
+export interface Extras {
+    orphanedEnhancers: Array<OrphanedEnhancerDefinition>;
+    attachedEnhancers: Array<AttachedEnhancerDefinition>;
+}

package/inspector/interfaces/extras.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/node.interface.d.ts

@@ -0,0 +1,49 @@
+import { EnhancerSubtype } from "@venok/core/constants";
+import { Scope } from "@venok/core/interfaces";
+import { InjectionToken } from "@venok/core/interfaces/modules";
+export type ModuleNode = {
+    metadata: {
+        type: "module";
+        global: boolean;
+        dynamic: boolean;
+        internal: boolean;
+    };
+};
+export type ClassNode = {
+    parent: string;
+    metadata: {
+        type: "provider" | "controller" | "middleware" | "injectable";
+        subtype?: EnhancerSubtype;
+        sourceModuleName: string;
+        durable: boolean;
+        static: boolean;
+        transient: boolean;
+        exported: boolean;
+        scope: Scope;
+        token: InjectionToken;
+        initTime: number;
+        /**
+         * Enhancers metadata collection
+         */
+        enhancers?: Array<{
+            id: string;
+            subtype: EnhancerSubtype;
+        } | {
+            name: string;
+            methodKey?: string;
+            subtype: EnhancerSubtype;
+        }>;
+        /**
+         * If true, node is a globally registered enhancer
+         */
+        global?: boolean;
+        /**
+         * If true, indicates that this node represents an internal provider
+         */
+        internal?: boolean;
+    };
+};
+export type Node = {
+    id: string;
+    label: string;
+} & (ClassNode | ModuleNode);

package/inspector/interfaces/node.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/serialized-graph-json.interface.d.ts

@@ -0,0 +1,14 @@
+import { SerializedGraphStatus } from '../serialized-graph';
+import { Edge } from './edge.interface';
+import { Entrypoint } from './entrypoint.interface';
+import { Extras } from './extras.interface';
+import { Node } from './node.interface';
+import { SerializedGraphMetadata } from './serialized-graph-metadata.interface';
+export interface SerializedGraphJson {
+    nodes: Record<string, Node>;
+    edges: Record<string, Edge>;
+    entrypoints: Record<string, Entrypoint<unknown>[]>;
+    extras: Extras;
+    status?: SerializedGraphStatus;
+    metadata?: SerializedGraphMetadata;
+}

package/inspector/interfaces/serialized-graph-json.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/interfaces/serialized-graph-metadata.interface.d.ts

@@ -0,0 +1,10 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+export interface SerializedGraphMetadata {
+    cause: {
+        type: 'unknown-dependencies' | 'unknown';
+        context?: InjectorDependencyContext;
+        moduleId?: string;
+        nodeId?: string;
+        error?: any;
+    };
+}

package/inspector/interfaces/serialized-graph-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/inspector/noop-graph-inspector.d.ts

@@ -0,0 +1,2 @@
+import { GraphInspector } from "./graph-inspector";
+export declare const NoopGraphInspector: GraphInspector;

package/inspector/noop-graph-inspector.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopGraphInspector = void 0;
+const graph_inspector_1 = require("./graph-inspector");
+const noop_helper_1 = require("@venok/core/helpers/noop.helper");
+exports.NoopGraphInspector = new Proxy(graph_inspector_1.GraphInspector.prototype, {
+    get: () => noop_helper_1.noop,
+});

package/inspector/partial-graph.host.d.ts

@@ -0,0 +1,7 @@
+import { SerializedGraph } from './serialized-graph';
+export declare class PartialGraphHost {
+    private static partialGraph;
+    static toJSON(): import("./interfaces/serialized-graph-json.interface").SerializedGraphJson;
+    static toString(): string;
+    static register(partialGraph: SerializedGraph): void;
+}