Variable FlowrConfig

Type Declaration

• amend: function

  • amend(
        this: void,
        config: FlowrConfig,
        amendmentFunc: (
            config: {
                abstractInterpretation: {
                    dataFrame: { maxColNames: ...; readLoadedData: ... };
                    wideningThreshold: number;
                };
                defaultEngine?: "r-shell"
                | "tree-sitter";
                defaultPlugins: ConfigPlugin<(...)>[];
                engines: ((...) | (...))[];
                gas: {
                    features: { [key: ...]: ... };
                    heapProvider?: (...) | (...);
                    thresholds: { memory: ...; timeMs: ...; [key: ...]: ... };
                    [key: string]: unknown;
                };
                ignoreLoadCalls: boolean;
                ignoreSourceCalls: boolean;
                incremental: {
                    alwaysIncremental: boolean;
                    parsing: { activated: ...; heuristics: ... };
                };
                inputSources?: {
                    cmdline?: ...;
                    const?: ...;
                    dconst?: ...;
                    ffi?: ...;
                    file?: ...;
                    glob?: ...;
                    lang?: ...;
                    linkedEntryPoints?: ...;
                    linkedObjects?: ...;
                    narrowing?: ...;
                    net?: ...;
                    options?: ...;
                    param?: ...;
                    pure?: ...;
                    rand?: ...;
                    scope?: ...;
                    system?: ...;
                    tempfile?: ...;
                    unknown?: ...;
                    user?: ...;
                };
                linter: { disabledRules: (...)[] };
                logLevel?:
                    | "debug"
                    | "silly"
                    | "trace"
                    | "info"
                    | "warn"
                    | "error"
                    | "fatal";
                project: {
                    basePackages?: (...)
                    | (...);
                    classification?: (...) | (...);
                    discovery?: (...) | (...);
                    failOnInaccessiblePath?: (...) | (...) | (...);
                    implicitSources?: (...) | (...);
                    resolveUnknownPathsOnDisk: boolean;
                    useProjectType?: (...) | (...);
                };
                repl: {
                    autoUseFileProtocol?: (...)
                    | (...)
                    | (...);
                    dfProcessorHeat: boolean;
                    hints: boolean;
                    plugins: (...)[];
                    queryStats?: (...) | (...) | (...);
                    quickStats: boolean;
                    showPlugins?: (...) | (...) | (...);
                };
                semantics: { environment: { overwriteBuiltIns: ... } };
                solver: {
                    evalStrings: boolean;
                    instrument: { dataflowExtractors?: ... };
                    resolveSource?: (...) | (...);
                    sigdb: {
                        additionalPaths?: ...;
                        assumedRVersion?: ...;
                        autoSync?: ...;
                        downloadRepo?: ...;
                        eagerlyLoad: ...;
                        eagerlyLoadExports: ...;
                        enabled: ...;
                        installedLibrary?: ...;
                        linkBaseR: ...;
                        linkBaseRCalls?: ...;
                        linkDescriptionDependencies: ...;
                        linkPackageCalls?: ...;
                        loadProjectDependencies: ...;
                        versionOverrides?: ...;
                        versionSelection?: ...;
                        warmInBackground?: ...;
                    };
                    slicer?: (...)
                    | (...);
                    trackEnvironments: boolean;
                    variables: VariableResolve;
                    versionManagement?: (...) | (...);
                };
                specializeConfig?: {
                    notebook?: ...;
                    package?: ...;
                    project?: ...;
                    script?: ...;
                    "shiny-app"?: ...;
                    unknown?: ...;
                };
                [key: string]: unknown;
            },
        ) => void
        | FlowrConfig,
    ): FlowrConfig

    Creates a new flowr config that has the updated values.

    Parameters

    • this: void
    • config: FlowrConfig
    • amendmentFunc: (
          config: {
              abstractInterpretation: {
                  dataFrame: { maxColNames: ...; readLoadedData: ... };
                  wideningThreshold: number;
              };
              defaultEngine?: "r-shell"
              | "tree-sitter";
              defaultPlugins: ConfigPlugin<(...)>[];
              engines: ((...) | (...))[];
              gas: {
                  features: { [key: ...]: ... };
                  heapProvider?: (...) | (...);
                  thresholds: { memory: ...; timeMs: ...; [key: ...]: ... };
                  [key: string]: unknown;
              };
              ignoreLoadCalls: boolean;
              ignoreSourceCalls: boolean;
              incremental: {
                  alwaysIncremental: boolean;
                  parsing: { activated: ...; heuristics: ... };
              };
              inputSources?: {
                  cmdline?: ...;
                  const?: ...;
                  dconst?: ...;
                  ffi?: ...;
                  file?: ...;
                  glob?: ...;
                  lang?: ...;
                  linkedEntryPoints?: ...;
                  linkedObjects?: ...;
                  narrowing?: ...;
                  net?: ...;
                  options?: ...;
                  param?: ...;
                  pure?: ...;
                  rand?: ...;
                  scope?: ...;
                  system?: ...;
                  tempfile?: ...;
                  unknown?: ...;
                  user?: ...;
              };
              linter: { disabledRules: (...)[] };
              logLevel?:
                  | "debug"
                  | "silly"
                  | "trace"
                  | "info"
                  | "warn"
                  | "error"
                  | "fatal";
              project: {
                  basePackages?: (...)
                  | (...);
                  classification?: (...) | (...);
                  discovery?: (...) | (...);
                  failOnInaccessiblePath?: (...) | (...) | (...);
                  implicitSources?: (...) | (...);
                  resolveUnknownPathsOnDisk: boolean;
                  useProjectType?: (...) | (...);
              };
              repl: {
                  autoUseFileProtocol?: (...)
                  | (...)
                  | (...);
                  dfProcessorHeat: boolean;
                  hints: boolean;
                  plugins: (...)[];
                  queryStats?: (...) | (...) | (...);
                  quickStats: boolean;
                  showPlugins?: (...) | (...) | (...);
              };
              semantics: { environment: { overwriteBuiltIns: ... } };
              solver: {
                  evalStrings: boolean;
                  instrument: { dataflowExtractors?: ... };
                  resolveSource?: (...) | (...);
                  sigdb: {
                      additionalPaths?: ...;
                      assumedRVersion?: ...;
                      autoSync?: ...;
                      downloadRepo?: ...;
                      eagerlyLoad: ...;
                      eagerlyLoadExports: ...;
                      enabled: ...;
                      installedLibrary?: ...;
                      linkBaseR: ...;
                      linkBaseRCalls?: ...;
                      linkDescriptionDependencies: ...;
                      linkPackageCalls?: ...;
                      loadProjectDependencies: ...;
                      versionOverrides?: ...;
                      versionSelection?: ...;
                      warmInBackground?: ...;
                  };
                  slicer?: (...)
                  | (...);
                  trackEnvironments: boolean;
                  variables: VariableResolve;
                  versionManagement?: (...) | (...);
              };
              specializeConfig?: {
                  notebook?: ...;
                  package?: ...;
                  project?: ...;
                  script?: ...;
                  "shiny-app"?: ...;
                  unknown?: ...;
              };
              [key: string]: unknown;
          },
      ) => void
      | FlowrConfig

    Returns FlowrConfig

• clone: function

  • clone(this: void, config: FlowrConfig): FlowrConfig

    Clones the given flowr config object.

    Parameters

    • this: void
    • config: FlowrConfig

    Returns FlowrConfig

• default: function

  • default(this: void): FlowrConfig

    The default configuration for flowR, used when no config file is found or when a config file is missing some options. You can use this as a base for your own config and only specify the options you want to change.

    Parameters

    • this: void

    Returns FlowrConfig

• forKind: function

  • forKind(this: void, config: FlowrConfig, kind: ProjectKind): FlowrConfig

    Resolves the configuration for the given ProjectKind by applying the matching FlowrConfig.specializeConfig entry to every key it names. What you configured wins over the entry, which in turn wins over flowR's default; a value that differs from the default counts as configured. Returns config itself if the kind has no entry, so callers can use this freely.

    Parameters

    • this: void
    • config: FlowrConfig
    • kind: ProjectKind

    Returns FlowrConfig

• fromFile: function

  • fromFile(
        this: void,
        configFile?: string,
        configWorkingDirectory?: string,
    ): FlowrConfig

    Loads the flowr config from the given file or the default locations. Please note that you can also use this without a path parameter to infer the config from flowR's default locations. This is mostly useful for user-facing features.

    Parameters

    • this: void
    • OptionalconfigFile: string
    • configWorkingDirectory: string = ...

    Returns FlowrConfig

• getForEngine: function

  • getForEngine<T extends "r-shell" | "tree-sitter">(
        this: void,
        config: FlowrConfig,
        engine: T,
    ): (EngineConfig & { type: T; }) | undefined

    Gets the configuration for the given engine type from the config.

    Type Parameters

    • T extends "r-shell" | "tree-sitter"

    Parameters

    • this: void
    • config: FlowrConfig
    • engine: T

    Returns (EngineConfig & { type: T; }) | undefined

• Readonlyname: "FlowrConfig"

• parse: function

  • parse(this: void, jsonString: string): FlowrConfig | undefined

    Parses the given JSON string as a flowR config file, returning the resulting config object if the parsing and validation were successful, or undefined if there was an error.

    Parameters

    • this: void
    • jsonString: string

    Returns FlowrConfig | undefined

• ReadonlySchema: ObjectSchema<any>

  The Joi schema for validating a config file, use this to validate your config file before using it. You can also use this to generate documentation for the config file format.

• setInConfig: function

  • setInConfig<Path extends string>(
        this: void,
        config: FlowrConfig,
        key: Path,
        value: PathValue<FlowrConfig, Path>,
    ): FlowrConfig

    Returns a new config object with the given value set at the given key, where the key is a dot-separated path to the value in the config object.

    Type Parameters

    • Path extends string

    Parameters

    • this: void
    • config: FlowrConfig
    • key: Path
    • value: PathValue<FlowrConfig, Path>

    Returns FlowrConfig

    See

    setInConfigInPlace for a version that modifies the config object in place instead of returning a new one.

    Example

    const config = FlowrConfig.default();
    const newConfig = FlowrConfig.setInConfig(config, 'solver.variables', VariableResolve.Builtin);
    console.log(config.solver.variables); // Output: "alias"
    console.log(newConfig.solver.variables); // Output: "builtin"
    Copy

• setInConfigInPlace: function

  • setInConfigInPlace<Path extends string>(
        this: void,
        config: FlowrConfig,
        key: Path,
        value: PathValue<FlowrConfig, Path>,
    ): void

    Modifies the given config object in place by setting the given value at the given key, where the key is a dot-separated path to the value in the config object.

    Type Parameters

    • Path extends string

    Parameters

    • this: void
    • config: FlowrConfig
    • key: Path
    • value: PathValue<FlowrConfig, Path>

    Returns void

    See

    setInConfig for a version that returns a new config object instead of modifying the given one in place.

• specializationFor: function

  • specializationFor(
        this: void,
        config: FlowrConfig,
        kind: ProjectKind,
    ):
        | {
            abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
            defaultEngine?: "r-shell" | "tree-sitter";
            defaultPlugins?: (...)[];
            engines?: (...)[];
            gas?: {
                features?: ...;
                heapProvider?: ...;
                thresholds?: ...;
                [key: ...]: ...;
            };
            ignoreLoadCalls?: boolean;
            ignoreSourceCalls?: boolean;
            incremental?: { alwaysIncremental?: ...; parsing?: ... };
            inputSources?: {
                cmdline?: ...;
                const?: ...;
                dconst?: ...;
                ffi?: ...;
                file?: ...;
                glob?: ...;
                lang?: ...;
                linkedEntryPoints?: ...;
                linkedObjects?: ...;
                narrowing?: ...;
                net?: ...;
                options?: ...;
                param?: ...;
                pure?: ...;
                rand?: ...;
                scope?: ...;
                system?: ...;
                tempfile?: ...;
                unknown?: ...;
                user?: ...;
            };
            linter?: { disabledRules?: ... };
            logLevel?:
                | "debug"
                | "silly"
                | "trace"
                | "info"
                | "warn"
                | "error"
                | "fatal";
            project?: {
                basePackages?: ...;
                classification?: ...;
                discovery?: ...;
                failOnInaccessiblePath?: ...;
                implicitSources?: ...;
                resolveUnknownPathsOnDisk?: ...;
                useProjectType?: ...;
            };
            repl?: {
                autoUseFileProtocol?: ...;
                dfProcessorHeat?: ...;
                hints?: ...;
                plugins?: ...;
                queryStats?: ...;
                quickStats?: ...;
                showPlugins?: ...;
            };
            semantics?: { environment?: ... };
            solver?: {
                evalStrings?: ...;
                instrument?: ...;
                resolveSource?: ...;
                sigdb?: ...;
                slicer?: ...;
                trackEnvironments?: ...;
                variables?: ...;
                versionManagement?: ...;
            };
            specializeConfig?: {
                notebook?: ...;
                package?: ...;
                project?: ...;
                script?: ...;
                "shiny-app"?: ...;
                unknown?: ...;
            };
            [key: string]: unknown;
        }
        | undefined

    The overwrite FlowrConfig.forKind applies for kind (with SpecializeConfigEntry.inherit resolved), or undefined.

    Parameters

    • this: void
    • config: FlowrConfig
    • kind: ProjectKind

    Returns
        | {
            abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
            defaultEngine?: "r-shell" | "tree-sitter";
            defaultPlugins?: (...)[];
            engines?: (...)[];
            gas?: {
                features?: ...;
                heapProvider?: ...;
                thresholds?: ...;
                [key: ...]: ...;
            };
            ignoreLoadCalls?: boolean;
            ignoreSourceCalls?: boolean;
            incremental?: { alwaysIncremental?: ...; parsing?: ... };
            inputSources?: {
                cmdline?: ...;
                const?: ...;
                dconst?: ...;
                ffi?: ...;
                file?: ...;
                glob?: ...;
                lang?: ...;
                linkedEntryPoints?: ...;
                linkedObjects?: ...;
                narrowing?: ...;
                net?: ...;
                options?: ...;
                param?: ...;
                pure?: ...;
                rand?: ...;
                scope?: ...;
                system?: ...;
                tempfile?: ...;
                unknown?: ...;
                user?: ...;
            };
            linter?: { disabledRules?: ... };
            logLevel?:
                | "debug"
                | "silly"
                | "trace"
                | "info"
                | "warn"
                | "error"
                | "fatal";
            project?: {
                basePackages?: ...;
                classification?: ...;
                discovery?: ...;
                failOnInaccessiblePath?: ...;
                implicitSources?: ...;
                resolveUnknownPathsOnDisk?: ...;
                useProjectType?: ...;
            };
            repl?: {
                autoUseFileProtocol?: ...;
                dfProcessorHeat?: ...;
                hints?: ...;
                plugins?: ...;
                queryStats?: ...;
                quickStats?: ...;
                showPlugins?: ...;
            };
            semantics?: { environment?: ... };
            solver?: {
                evalStrings?: ...;
                instrument?: ...;
                resolveSource?: ...;
                sigdb?: ...;
                slicer?: ...;
                trackEnvironments?: ...;
                variables?: ...;
                versionManagement?: ...;
            };
            specializeConfig?: {
                notebook?: ...;
                package?: ...;
                project?: ...;
                script?: ...;
                "shiny-app"?: ...;
                unknown?: ...;
            };
            [key: string]: unknown;
        }
        | undefined

    • {
          abstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... };
          defaultEngine?: "r-shell" | "tree-sitter";
          defaultPlugins?: (...)[];
          engines?: (...)[];
          gas?: {
              features?: ...;
              heapProvider?: ...;
              thresholds?: ...;
              [key: ...]: ...;
          };
          ignoreLoadCalls?: boolean;
          ignoreSourceCalls?: boolean;
          incremental?: { alwaysIncremental?: ...; parsing?: ... };
          inputSources?: {
              cmdline?: ...;
              const?: ...;
              dconst?: ...;
              ffi?: ...;
              file?: ...;
              glob?: ...;
              lang?: ...;
              linkedEntryPoints?: ...;
              linkedObjects?: ...;
              narrowing?: ...;
              net?: ...;
              options?: ...;
              param?: ...;
              pure?: ...;
              rand?: ...;
              scope?: ...;
              system?: ...;
              tempfile?: ...;
              unknown?: ...;
              user?: ...;
          };
          linter?: { disabledRules?: ... };
          logLevel?:
              | "debug"
              | "silly"
              | "trace"
              | "info"
              | "warn"
              | "error"
              | "fatal";
          project?: {
              basePackages?: ...;
              classification?: ...;
              discovery?: ...;
              failOnInaccessiblePath?: ...;
              implicitSources?: ...;
              resolveUnknownPathsOnDisk?: ...;
              useProjectType?: ...;
          };
          repl?: {
              autoUseFileProtocol?: ...;
              dfProcessorHeat?: ...;
              hints?: ...;
              plugins?: ...;
              queryStats?: ...;
              quickStats?: ...;
              showPlugins?: ...;
          };
          semantics?: { environment?: ... };
          solver?: {
              evalStrings?: ...;
              instrument?: ...;
              resolveSource?: ...;
              sigdb?: ...;
              slicer?: ...;
              trackEnvironments?: ...;
              variables?: ...;
              versionManagement?: ...;
          };
          specializeConfig?: {
              notebook?: ...;
              package?: ...;
              project?: ...;
              script?: ...;
              "shiny-app"?: ...;
              unknown?: ...;
          };
          [key: string]: unknown;
      }

      • [key: string]: unknown

      • Optional ReadonlyabstractInterpretation?: { dataFrame?: ...; wideningThreshold?: ... }

        Configuration options for abstract interpretation

        • Optional ReadonlydataFrame?: ...

          The configuration of the shape inference for data frames

        • Optional ReadonlywideningThreshold?: ...

          The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

      • Optional ReadonlydefaultEngine?: "r-shell" | "tree-sitter"

        The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

      • Optional ReadonlydefaultPlugins?: (...)[]

        Plugins to load by default when creating a new FlowrAnalyzer

      • Optional Readonlyengines?: (...)[]

        The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

      • Optional Readonlygas?: { features?: ...; heapProvider?: ...; thresholds?: ...; [key: ...]: ... }

        Resource-usage guard (gas) configuration. Gas checks are disabled by default (all feature factors are 0). Set a feature factor > 0 to enable checking for that feature.

        See

        • FlowrGasConfig
        • ReadOnlyFlowrAnalyzerGasContext

        • Optional Readonlyfeatures?: ...

          Per-feature sensitivity factors. Missing or 0 disables checking with zero overhead.

        • Optional ReadonlyheapProvider?: ...

          Custom heap statistics source (programmatic configs only), overriding the built-in detection (v8 module, then Chromium's performance.memory). Return undefined to skip the memory check.

        • Optional Readonlythresholds?: ...

          Thresholds scaled by each feature factor before comparison, optionally bounded per feature (see GasThresholdSpec).

      • Optional ReadonlyignoreLoadCalls?: boolean

        Whether load calls should be ignored, causing processLoadCall's behavior to be skipped

      • Optional ReadonlyignoreSourceCalls?: boolean

        Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

      • Optional Readonlyincremental?: { alwaysIncremental?: ...; parsing?: ... }

        • Optional ReadonlyalwaysIncremental?: ...

          Always take the incremental path, regardless of heuristics

        • Optional Readonlyparsing?: ...

      • Optional ReadonlyinputSources?: {
            cmdline?: ...;
            const?: ...;
            dconst?: ...;
            ffi?: ...;
            file?: ...;
            glob?: ...;
            lang?: ...;
            linkedEntryPoints?: ...;
            linkedObjects?: ...;
            narrowing?: ...;
            net?: ...;
            options?: ...;
            param?: ...;
            pure?: ...;
            rand?: ...;
            scope?: ...;
            system?: ...;
            tempfile?: ...;
            unknown?: ...;
            user?: ...;
        }

        Teaches the InputSourcesQuery|input-sources analysis (and with it the problematic-inputs linter) about further frameworks. Everything here is added to what flowR already knows, so a shiny app keeps its input even when you declare your own. Usually set per ProjectKind via specializeConfig.

        See

        InputClassifierConfig - for what the entries mean

        • Optionalcmdline?: ...

        • Optionalconst?: ...

        • Optionaldconst?: ...

        • Optionalffi?: ...

        • Optionalfile?: ...

        • Optionalglob?: ...

        • Optionallang?: ...

        • OptionallinkedEntryPoints?: ...

          Calls that hand a function to a framework, which then binds linkedObjects to its parameters by position.

          See

          LinkedInputEntryPoint

        • OptionallinkedObjects?: ...

          Objects provided by a framework rather than by the code itself, like shiny's input.

          See

          LinkedInputObject

        • Optionalnarrowing?: ...

          Functions whose result is bounded by one of their arguments (classified by that argument alone).

          See

          NarrowingFunction

        • Optionalnet?: ...

        • Optionaloptions?: ...

        • Optionalparam?: ...

        • Optionalpure?: ...

          Functions which are considered to be pure (i.e., deterministic, trusted, safe, idempotent on the lub of the input types)

        • Optionalrand?: ...

        • Optionalscope?: ...

        • Optionalsystem?: ...

        • Optionaltempfile?: ...

        • Optionalunknown?: ...

        • Optionaluser?: ...

      • Optional Readonlylinter?: { disabledRules?: ... }

        Linter configuration, usually specialized per ProjectKind via FlowrConfig.specializeConfig.

        • Optional ReadonlydisabledRules?: ...

          Rule names excluded from the default rule set (a rule requested explicitly still runs).

      • Optional ReadonlylogLevel?: "debug" | "silly" | "trace" | "info" | "warn" | "error" | "fatal"

      • Optional Readonlyproject?: {
            basePackages?: ...;
            classification?: ...;
            discovery?: ...;
            failOnInaccessiblePath?: ...;
            implicitSources?: ...;
            resolveUnknownPathsOnDisk?: ...;
            useProjectType?: ...;
        }

        • OptionalbasePackages?: ...

          The packages considered part of R itself, used e.g. by the project query to classify dependencies. If unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

        • Optionalclassification?: ...

          Overrides for the signals flowR uses to classify the ProjectKind; unset fields keep the built-in defaults.

        • Optionaldiscovery?: ...

          Scoping options for the default project discovery.

        • OptionalfailOnInaccessiblePath?: ...

          Whether a directory that cannot be traversed during file discovery (e.g. due to permissions) aborts the analysis; when false (the default) such paths are logged and skipped.

        • OptionalimplicitSources?: ...

          Files a framework loads on its own, without any source() call (e.g. global.R in a shiny app), in load order. Entries are case-insensitive globs (R/*.R) matched against the path, a plain name matches any file with that name; entries matching nothing are warned about. Usually set per ProjectKind via FlowrConfig.specializeConfig.

        • OptionalresolveUnknownPathsOnDisk?: ...

          Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files

        • OptionaluseProjectType?: ...

          Overwrite the ProjectKind flowR would otherwise infer from the analyzed files, e.g. when auto-detection guesses wrong.

      • Optional Readonlyrepl?: {
            autoUseFileProtocol?: ...;
            dfProcessorHeat?: ...;
            hints?: ...;
            plugins?: ...;
            queryStats?: ...;
            quickStats?: ...;
            showPlugins?: ...;
        }

        Configuration options for the REPL

        • OptionalautoUseFileProtocol?: ...

          Automatically use the file protocol for inputs that look like paths (default true)

        • OptionaldfProcessorHeat?: ...

          This instruments the dataflow processors to count how often each processor is called

        • Optionalhints?: ...

          Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

        • Optionalplugins?: ...

          Plugins to load in REPL mode

        • OptionalqueryStats?: ...

          Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

        • OptionalquickStats?: ...

          Whether to show quick stats in the REPL after each evaluation

        • OptionalshowPlugins?: ...

          Whether :version grays out the plugins that did not activate during the last analysis (default false)

      • Optional Readonlysemantics?: { environment?: ... }

        Configure language semantics and how flowR handles them

        • Optional Readonlyenvironment?: ...

          Semantics regarding the handling of the environment

      • Optional Readonlysolver?: {
            evalStrings?: ...;
            instrument?: ...;
            resolveSource?: ...;
            sigdb?: ...;
            slicer?: ...;
            trackEnvironments?: ...;
            variables?: ...;
            versionManagement?: ...;
        }

        How to resolve constants, constraints, cells, …

        • Optional ReadonlyevalStrings?: ...

          Should we include eval(parse(text="...")) calls in the dataflow graph?

        • Optional Readonlyinstrument?: ...

          These keys are only intended for use within code, allowing to instrument the dataflow analyzer!

        • Optional ReadonlyresolveSource?: ...

          If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

        • Optional Readonlysigdb?: ...

          Resolving library()/use() exports from a signature database (e.g. the bundled flowr-sigdb).

        • Optionalslicer?: ...

          The configuration for flowR's slicer

        • Optional ReadonlytrackEnvironments?: ...

          Track user-created environments (new.env(), assign(..., envir=e), get(..., envir=e), local({}, envir=e), e$x <- v, attach(e)) with precise per-variable envState. When disabled all envir-style calls fall through to the conservative global treatment.

        • Optional Readonlyvariables?: ...

          How to resolve variables and their values

        • Optional ReadonlyversionManagement?: ...

          Policies for reasoning about dependency versions (independent of how the signature database is loaded).

      • Optional ReadonlyspecializeConfig?: {
            notebook?: ...;
            package?: ...;
            project?: ...;
            script?: ...;
            "shiny-app"?: ...;
            unknown?: ...;
        }

        Overwrite (parts of) this configuration depending on the ProjectKind flowR detects for the project, e.g. to give a shiny app its implicit sources. An entry may inherit another kind's overwrite (merged first, with the entry's own keys winning) to avoid repeating it. Resolve it with FlowrConfig.forKind.

    • undefined