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

    Variable DataflowConst

    Dataflow: {
        argumentsBoundTo(
            this: void,
            graph: DataflowGraph,
            parameter: NodeId,
        ): Generator<NodeId>;
        assignedValueOf(
            this: void,
            def: NodeId,
            graph: DataflowGraph,
        ): NodeId | undefined;
        calleeIdsOf(this: void, graph: DataflowGraph, call: NodeId): NodeId[];
        calleesOf(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): Generator<DataflowGraphVertexFunctionDefinition>;
        callsIn(
            this: void,
            definition: DataflowGraphVertexFunctionDefinition,
            graph: DataflowGraph,
        ): Generator<[NodeId, DataflowGraphVertexFunctionCall]>;
        callsOnlyKnownFunctions(
            this: void,
            call: NodeId,
            graph: DataflowGraph,
            environment?: REnvironmentInformation,
        ): boolean;
        callTargetsOf(
            this: void,
            call: NodeId,
            graph: DataflowGraph,
            environment?: REnvironmentInformation,
            resolver?: LinkedFunctionResolver,
        ): NodeId[];
        create: {
            empty: (
                this: void,
                cleanEnv?: REnvironmentInformation,
                idMap?: AstIdMap,
            ) => DataflowGraphBuilder<DataflowGraphVertexInfo>;
        };
        definedBySuperAssignment(
            this: void,
            graph: DataflowGraph,
            def: NodeId,
        ): boolean;
        definitionsByName(
            this: void,
            graph: DataflowGraph,
        ): DefaultMap<BrandedIdentifier, NodeId[]>;
        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;
            missingVertex<Graph>(
                this: void,
                ctx: GraphDiffContext<Graph>,
                id: NodeId,
            ): 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;
            vertexCount<Graph>(
                this: void,
                ctx: GraphDiffContext<Graph>,
                left: number,
                right: number,
            ): 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;
        hasEdge(
            this: void,
            graph: DataflowGraph,
            from: NodeId,
            to: NodeId,
            types: EdgeType,
        ): boolean;
        invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            cleanEnv: REnvironmentInformation,
        ): G;
        isQuoted(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            withOutgoing?: boolean,
        ): boolean;
        library: {
            attaches: (
                this: void,
                ctx: FlowrAnalyzerContext,
                pkg: BrandedNamespace,
                spec?: AttachSpec,
            ) => readonly BrandedNamespace[];
            layers: (
                this: void,
                ctx: FlowrAnalyzerContext,
                pkg: BrandedNamespace,
                spec?: AttachSpec,
            ) => readonly Environment[];
            loads: (
                this: void,
                ctx: FlowrAnalyzerContext,
                pkg: BrandedNamespace,
            ) => readonly BrandedNamespace[];
            name: "library";
            reexports: (
                this: void,
                ctx: FlowrAnalyzerContext,
                pkg: BrandedNamespace,
            ) => ReadonlyMap<BrandedIdentifier, BrandedNamespace>;
        };
        name: "Dataflow";
        origin: (
            this: void,
            dfg: DataflowGraph,
            id: NodeId,
        ) => Origin[] | undefined;
        packagesOf(
            this: void,
            nodes: Iterable<NodeId>,
            graph: DataflowGraph,
            includeBaseR?: boolean,
        ): Set<BrandedNamespace>;
        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;
        refsToSymbol(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): NodeId[] | undefined;
        resolveGraphCriteria<
            G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
        >(
            graph: G,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): G;
        sideEffects: {
            ambientAccess: (
                this: void,
                from: AmbientSource,
                scope: AmbientScope,
                opts?: AmbientAccessOptions,
            ) => AmbientAccess;
            ambientAccessOfFunctions: (
                this: void,
                from: AmbientSource,
            ) => Map<NodeId, AmbientAccess>;
            callGraphSummaries: <T>(
                this: void,
                graph: DataflowGraph,
                own: (
                    id: NodeId,
                    fdef: DataflowGraphVertexFunctionDefinition,
                ) => Iterable<(...)>,
            ) => Relation<NodeId, T>;
            foldCallGraph: <M>(
                this: void,
                graph: DataflowGraph,
                monoid: Monoid<M>,
                own: (id: NodeId, fdef: DataflowGraphVertexFunctionDefinition) => M,
            ) => Map<NodeId, M>;
            propagateTransitive: (
                this: void,
                graph: DataflowGraph,
                environment: REnvironmentInformation,
                ctx: FlowrAnalyzerContext,
                defined?: Set<BrandedIdentifier>,
                open?: readonly IdentifierReference[],
            ) => {
                environment: REnvironmentInformation;
                escapedNames: Set<(...)>;
                grew: boolean;
            };
        };
        sourcesOf(
            this: void,
            graph: DataflowGraph,
            node: NodeId,
            types: EdgeType,
        ): NodeId[];
        superAssigns(this: void, graph: DataflowGraph, id: NodeId): boolean;
        targetsOf(
            this: void,
            graph: DataflowGraph,
            node: NodeId,
            types: EdgeType,
        ): NodeId[];
        valueIsUsed(this: void, id: NodeId, graph: DataflowGraph): boolean;
        valueSources(
            this: void,
            id: NodeId,
            graph: DataflowGraph,
            opts?: { budget?: number; throughAccess?: boolean },
        ): NodeId[] | undefined;
        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.

    Type Declaration

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

    Settings
    Member Visibility