@eagleoutice/flowr - v2.15.9
    Preparing search index...

    Variable DataflowConst

    Dataflow: {
        argumentsBoundTo(
            this: void,
            graph: DataflowGraph,
            parameter: NodeId,
        ): Generator<NodeId>;
        calleesOf(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): Generator<DataflowGraphVertexFunctionDefinition>;
        create: {
            empty: (
                this: void,
                cleanEnv?: REnvironmentInformation,
                idMap?: AstIdMap,
            ) => DataflowGraphBuilder<DataflowGraphVertexInfo>;
        };
        diff: {
            edges<Edge, Graph>(
                this: void,
                ctx: GraphDiffContext<Graph>,
                id: NodeId,
                lEdges: ReadonlyMap<NodeId, Edge> | undefined,
                rEdges: ReadonlyMap<NodeId, Edge> | undefined,
                diffEdge: (
                    edge: Edge,
                    otherEdge: Edge,
                    ctx: GraphDiffContext<Graph>,
                    id: NodeId,
                    target: NodeId,
                ) => void,
            ): void;
            outgoingEdges<EdgeMap, Graph extends EdgeIndexedGraph<EdgeMap>>(
                this: void,
                ctx: GraphDiffContext<Graph>,
                diffEdges: (
                    ctx: GraphDiffContext<Graph>,
                    id: NodeId,
                    lEdges: EdgeMap | undefined,
                    rEdges: EdgeMap | undefined,
                ) => void,
                project?: (edges: EdgeMap) => (...) | (...),
            ): void;
        };
        diffGraphs<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            left: NamedGraph<G>,
            right: NamedGraph<G>,
            config?: Partial<GenericDiffConfiguration>,
        ): GraphDifferenceReport;
        hasComputedArguments(this: void, id: NodeId, graph: DataflowGraph): boolean;
        invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            cleanEnv: REnvironmentInformation,
        ): G;
        isQuoted(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            withOutgoing?: boolean,
        ): boolean;
        name: "Dataflow";
        origin: (
            this: void,
            dfg: DataflowGraph,
            id: NodeId,
        ) => Origin[] | undefined;
        packagesOf(
            this: void,
            nodes: Iterable<NodeId>,
            graph: DataflowGraph,
            includeBaseR?: boolean,
        ): Set<string>;
        parametersOf(
            this: void,
            definition: DataflowGraphVertexFunctionDefinition,
        ): NodeId[];
        provenance(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            consider?: ReadonlySet<NodeId>,
            followEdges?: number | undefined,
        ): Set<NodeId>;
        provenanceGraph(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            consider?: ReadonlySet<NodeId>,
        ): DataflowGraph;
        qualify(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            qualifyBaseR?: boolean,
        ): Identifier | undefined;
        qualifyAll(
            this: void,
            graph: DataflowGraph,
            qualifyBaseR?: boolean,
        ): ReadonlyMap<NodeId, Identifier | undefined>;
        reachable<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            seed: NodeId | Iterable<NodeId, any, any>,
            __namedParameters?: ReachOptions,
        ): Set<NodeId>;
        reaches<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            from: NodeId,
            to: NodeId,
            graph: G,
            knownReachability?: DefaultMap<NodeId, Set<NodeId>>,
        ): boolean;
        reduceAndInvertGraph<
            G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
        >(
            this: void,
            graph: G,
            select: ReadonlySet<NodeId>,
            cleanEnv: REnvironmentInformation,
        ): G;
        reduceGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            select: ReadonlySet<NodeId>,
            includeMissingTargets?: boolean,
        ): G;
        resolveGraphCriteria<
            G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
        >(
            graph: G,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): G;
        sideEffects: {
            callGraphSummaries: <T>(
                this: void,
                graph: DataflowGraph,
                own: (
                    id: NodeId,
                    fdef: DataflowGraphVertexFunctionDefinition,
                ) => Iterable<(...)>,
            ) => Map<NodeId, Set<(...)>>;
            propagateTransitive: (
                this: void,
                graph: DataflowGraph,
                environment: REnvironmentInformation,
                ctx: FlowrAnalyzerContext,
                defined?: Set<string>,
            ) => {
                environment: REnvironmentInformation;
                escapedNames: Set<(...)>;
                grew: boolean;
            };
        };
        valueIsUsed(this: void, id: NodeId, graph: DataflowGraph): boolean;
        visitDfg(
            this: void,
            graph: DataflowGraph,
            start: NodeId,
            onVertex: (vtx: DataflowGraphVertexInfo) => boolean | void,
        ): void;
        visualize: {
            mermaid: {
                convert(
                    this: void,
                    config: MermaidGraphConfiguration,
                ): { mermaid: MermaidGraph; string: string };
                name: "DataflowMermaid";
                raw(
                    this: void,
                    graph: DataflowGraph<(...), (...)> | DataflowInformation,
                    includeEnvironments?: boolean,
                    mark?: ReadonlySet<(...)>,
                    simplified?: boolean,
                    qualifyBaseR?: boolean,
                ): string;
                url(
                    this: void,
                    graph: DataflowGraph<(...), (...)> | DataflowInformation,
                    includeEnvironments?: boolean,
                    mark?: ReadonlySet<(...)>,
                    simplified?: boolean,
                    qualifyBaseR?: boolean,
                ): string;
            };
            quads: {
                convert: (
                    graph: DataflowGraph,
                    config: QuadSerializationConfiguration,
                ) => string;
            };
        };
    } = ...

    This is the root helper object to work with the DataflowGraph.

    What it used to re-expose under a second name is imported directly instead: DfEdge for the edges, CallGraph for the call-graph view, Resolve for name and value resolution, and DataflowGraph for the graph itself.

    Type Declaration

    dataflow This is the root helper object to work with the DataflowGraph.

    Dataflow.origin(graph, id);                  // where the use at `id` comes from
    DfEdge.includesType(edge, EdgeType.Reads);   // the edge helpers
    Dataflow.visualize.mermaid.url(graph);       // a link to the rendered graph

    Settings
    Member Visibility