@eagleoutice/flowr 2.6.1 → 2.6.3

package/project/plugins/file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin.d.ts

@@ -0,0 +1,22 @@
+import type { PathLike } from 'fs';
+import { SemVer } from 'semver';
+import type { FlowrAnalyzerContext } from '../../../context/flowr-analyzer-context';
+import type { FlowrFileProvider } from '../../../context/flowr-file';
+import { FlowrAnalyzerFilePlugin } from '../flowr-analyzer-file-plugin';
+import { FlowrJupyterFile } from './flowr-jupyter-file';
+/**
+ * The plugin provides support for Jupyter (`.ipynb`) files
+ */
+export declare class FlowrAnalyzerJupyterFilePlugin extends FlowrAnalyzerFilePlugin {
+    readonly name = "ipynb-file-plugin";
+    readonly description = "Parses Jupyter files";
+    readonly version: SemVer;
+    private readonly pattern;
+    /**
+     * Creates a new instance of the Jupyter file plugin.
+     * @param filePattern - The pattern to identify Jupyter files, see {@link IpynbPattern} for the default pattern.
+     */
+    constructor(filePattern?: RegExp);
+    applies(file: PathLike): boolean;
+    protected process(_ctx: FlowrAnalyzerContext, arg: FlowrFileProvider<string>): FlowrJupyterFile;
+}

package/project/plugins/file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerJupyterFilePlugin = void 0;
+const semver_1 = require("semver");
+const flowr_analyzer_file_plugin_1 = require("../flowr-analyzer-file-plugin");
+const built_in_source_1 = require("../../../../dataflow/internal/process/functions/call/built-in/built-in-source");
+const flowr_jupyter_file_1 = require("./flowr-jupyter-file");
+const IpynbPattern = /\.ipynb$/i;
+/**
+ * The plugin provides support for Jupyter (`.ipynb`) files
+ */
+class FlowrAnalyzerJupyterFilePlugin extends flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin {
+    name = 'ipynb-file-plugin';
+    description = 'Parses Jupyter files';
+    version = new semver_1.SemVer('0.1.0');
+    pattern;
+    /**
+     * Creates a new instance of the Jupyter file plugin.
+     * @param filePattern - The pattern to identify Jupyter files, see {@link IpynbPattern} for the default pattern.
+     */
+    constructor(filePattern = IpynbPattern) {
+        super();
+        this.pattern = filePattern;
+    }
+    applies(file) {
+        return this.pattern.test((0, built_in_source_1.platformBasename)(file.toString()));
+    }
+    process(_ctx, arg) {
+        return flowr_jupyter_file_1.FlowrJupyterFile.from(arg);
+    }
+}
+exports.FlowrAnalyzerJupyterFilePlugin = FlowrAnalyzerJupyterFilePlugin;
+//# sourceMappingURL=flowr-analyzer-jupyter-file-plugin.js.map

package/project/plugins/file-plugins/notebooks/flowr-analyzer-qmd-file-plugin.d.ts

@@ -0,0 +1,22 @@
+import type { PathLike } from 'fs';
+import { SemVer } from 'semver';
+import type { FlowrAnalyzerContext } from '../../../context/flowr-analyzer-context';
+import type { FlowrFileProvider } from '../../../context/flowr-file';
+import { FlowrAnalyzerFilePlugin } from '../flowr-analyzer-file-plugin';
+import { FlowrRMarkdownFile } from './flowr-rmarkdown-file';
+/**
+ * The plugin provides support for Quarto R Markdown (`.qmd`) files
+ */
+export declare class FlowrAnalyzerQmdFilePlugin extends FlowrAnalyzerFilePlugin {
+    readonly name = "qmd-file-plugin";
+    readonly description = "Parses Quarto R Markdown files";
+    readonly version: SemVer;
+    private readonly pattern;
+    /**
+     * Creates a new instance of the Quarto R Markdown file plugin.
+     * @param filePattern - The pattern to identify Quarto R Markdown files, see {@link QmdPattern} for the default pattern.
+     */
+    constructor(filePattern?: RegExp);
+    applies(file: PathLike): boolean;
+    protected process(_ctx: FlowrAnalyzerContext, arg: FlowrFileProvider<string>): FlowrRMarkdownFile;
+}

package/project/plugins/file-plugins/notebooks/flowr-analyzer-qmd-file-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerQmdFilePlugin = void 0;
+const semver_1 = require("semver");
+const flowr_analyzer_file_plugin_1 = require("../flowr-analyzer-file-plugin");
+const flowr_rmarkdown_file_1 = require("./flowr-rmarkdown-file");
+const built_in_source_1 = require("../../../../dataflow/internal/process/functions/call/built-in/built-in-source");
+const QmdPattern = /\.qmd$/i;
+/**
+ * The plugin provides support for Quarto R Markdown (`.qmd`) files
+ */
+class FlowrAnalyzerQmdFilePlugin extends flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin {
+    name = 'qmd-file-plugin';
+    description = 'Parses Quarto R Markdown files';
+    version = new semver_1.SemVer('0.1.0');
+    pattern;
+    /**
+     * Creates a new instance of the Quarto R Markdown file plugin.
+     * @param filePattern - The pattern to identify Quarto R Markdown files, see {@link QmdPattern} for the default pattern.
+     */
+    constructor(filePattern = QmdPattern) {
+        super();
+        this.pattern = filePattern;
+    }
+    applies(file) {
+        return this.pattern.test((0, built_in_source_1.platformBasename)(file.toString()));
+    }
+    process(_ctx, arg) {
+        return flowr_rmarkdown_file_1.FlowrRMarkdownFile.from(arg);
+    }
+}
+exports.FlowrAnalyzerQmdFilePlugin = FlowrAnalyzerQmdFilePlugin;
+//# sourceMappingURL=flowr-analyzer-qmd-file-plugin.js.map

package/project/plugins/file-plugins/notebooks/flowr-analyzer-rmd-file-plugin.d.ts

@@ -0,0 +1,22 @@
+import type { PathLike } from 'fs';
+import { SemVer } from 'semver';
+import type { FlowrAnalyzerContext } from '../../../context/flowr-analyzer-context';
+import { type FlowrFileProvider } from '../../../context/flowr-file';
+import { FlowrAnalyzerFilePlugin } from '../flowr-analyzer-file-plugin';
+import { FlowrRMarkdownFile } from './flowr-rmarkdown-file';
+/**
+ * The plugin provides support for R Markdown (`.rmd`) files
+ */
+export declare class FlowrAnalyzerRmdFilePlugin extends FlowrAnalyzerFilePlugin {
+    readonly name = "rmd-file-plugin";
+    readonly description = "Parses R Markdown files";
+    readonly version: SemVer;
+    private readonly pattern;
+    /**
+     * Creates a new instance of the R Markdown file plugin.
+     * @param filePattern - The pattern to identify R Markdown files, see {@link RmdPattern} for the default pattern.
+     */
+    constructor(filePattern?: RegExp);
+    applies(file: PathLike): boolean;
+    protected process(_ctx: FlowrAnalyzerContext, arg: FlowrFileProvider<string>): FlowrRMarkdownFile;
+}

package/project/plugins/file-plugins/notebooks/flowr-analyzer-rmd-file-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerRmdFilePlugin = void 0;
+const semver_1 = require("semver");
+const flowr_analyzer_file_plugin_1 = require("../flowr-analyzer-file-plugin");
+const flowr_rmarkdown_file_1 = require("./flowr-rmarkdown-file");
+const built_in_source_1 = require("../../../../dataflow/internal/process/functions/call/built-in/built-in-source");
+const RmdPattern = /\.rmd$/i;
+/**
+ * The plugin provides support for R Markdown (`.rmd`) files
+ */
+class FlowrAnalyzerRmdFilePlugin extends flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin {
+    name = 'rmd-file-plugin';
+    description = 'Parses R Markdown files';
+    version = new semver_1.SemVer('0.1.0');
+    pattern;
+    /**
+     * Creates a new instance of the R Markdown file plugin.
+     * @param filePattern - The pattern to identify R Markdown files, see {@link RmdPattern} for the default pattern.
+     */
+    constructor(filePattern = RmdPattern) {
+        super();
+        this.pattern = filePattern;
+    }
+    applies(file) {
+        return this.pattern.test((0, built_in_source_1.platformBasename)(file.toString()));
+    }
+    process(_ctx, arg) {
+        return flowr_rmarkdown_file_1.FlowrRMarkdownFile.from(arg);
+    }
+}
+exports.FlowrAnalyzerRmdFilePlugin = FlowrAnalyzerRmdFilePlugin;
+//# sourceMappingURL=flowr-analyzer-rmd-file-plugin.js.map

package/project/plugins/file-plugins/notebooks/flowr-jupyter-file.d.ts

@@ -0,0 +1,20 @@
+import type { FlowrFileProvider } from '../../../context/flowr-file';
+import { FlowrFile } from '../../../context/flowr-file';
+/**
+ * This decorates a text file and parses its contents as a Jupyter file.
+ * Finnaly, it provides access to the single cells, and all cells fused together as one R file.
+ */
+export declare class FlowrJupyterFile extends FlowrFile<string> {
+    private readonly wrapped;
+    /**
+     * Prefer the static {@link FlowrRMarkdownFile.from} method
+     * @param file - the file to load as R Markdown
+     */
+    constructor(file: FlowrFileProvider<string>);
+    /**
+     * Loads and parses the content of the wrapped file.
+     * @returns RmdInfo
+     */
+    protected loadContent(): string;
+    static from(file: FlowrFileProvider<string> | FlowrJupyterFile): FlowrJupyterFile;
+}

package/project/plugins/file-plugins/notebooks/flowr-jupyter-file.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrJupyterFile = void 0;
+const flowr_file_1 = require("../../../context/flowr-file");
+/**
+ * This decorates a text file and parses its contents as a Jupyter file.
+ * Finnaly, it provides access to the single cells, and all cells fused together as one R file.
+ */
+class FlowrJupyterFile extends flowr_file_1.FlowrFile {
+    wrapped;
+    /**
+     * Prefer the static {@link FlowrRMarkdownFile.from} method
+     * @param file - the file to load as R Markdown
+     */
+    constructor(file) {
+        super(file.path(), flowr_file_1.FileRole.Source);
+        this.wrapped = file;
+    }
+    /**
+     * Loads and parses the content of the wrapped file.
+     * @returns RmdInfo
+     */
+    loadContent() {
+        return loadJupyter(this.wrapped.content());
+    }
+    static from(file) {
+        return file instanceof FlowrJupyterFile ? file : new FlowrJupyterFile(file);
+    }
+}
+exports.FlowrJupyterFile = FlowrJupyterFile;
+function loadJupyter(content) {
+    const nb = JSON.parse(content);
+    return nb.cells.map(cell => {
+        if (cell.cell_type === 'code') {
+            return typeof cell.source === 'object' ? cell.source.join('') : cell.source;
+        }
+        else {
+            return typeof cell.source === 'object' ? cell.source.map(s => `# ${s}`).join('') : `# ${cell.source}`;
+        }
+    }).join('\n');
+}
+//# sourceMappingURL=flowr-jupyter-file.js.map

package/project/plugins/file-plugins/notebooks/flowr-rmarkdown-file.d.ts

@@ -0,0 +1,59 @@
+import type { FlowrFileProvider } from '../../../context/flowr-file';
+import { FlowrFile } from '../../../context/flowr-file';
+import { type Node } from 'commonmark';
+/**
+ * This decorates a text file and parses its contents as a R Markdown file.
+ * Finnaly, it provides access to the single cells, and all cells fused together as one R file.
+ */
+export declare class FlowrRMarkdownFile extends FlowrFile<string> {
+    private data?;
+    private readonly wrapped;
+    /**
+     * Prefer the static {@link FlowrRMarkdownFile.from} method
+     * @param file - the file to load as R Markdown
+     */
+    constructor(file: FlowrFileProvider<string>);
+    get rmd(): RmdInfo;
+    /**
+     * Loads and parses the content of the wrapped file.
+     * @returns RmdInfo
+     */
+    protected loadContent(): string;
+    static from(file: FlowrFileProvider<string> | FlowrRMarkdownFile): FlowrRMarkdownFile;
+}
+export interface CodeBlock {
+    options: string;
+    code: string;
+}
+export type CodeBlockEx = CodeBlock & {
+    startpos: {
+        line: number;
+        col: number;
+    };
+};
+export interface RmdInfo {
+    content: string;
+    blocks: CodeBlock[];
+    options: object;
+}
+/**
+ * Parse the contents of a RMarkdown file into complete code and blocks
+ * @param raw - the raw file content
+ * @returns Rmd Info
+ */
+export declare function parseRMarkdownFile(raw: string): RmdInfo;
+/**
+ * Checks whether a CommonMark node is an R code block
+ */
+export declare function isRCodeBlock(node: Node): node is Node & {
+    literal: string;
+    info: string;
+};
+/**
+ * Restores an Rmd file from code blocks, filling non-code lines with empty lines
+ */
+export declare function restoreBlocksWithoutMd(blocks: CodeBlockEx[], totalLines: number): string;
+/**
+ * Parses the options of an R code block from its header and content
+ */
+export declare function parseCodeBlockOptions(header: string, content: string): string;

package/project/plugins/file-plugins/notebooks/flowr-rmarkdown-file.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrRMarkdownFile = void 0;
+exports.parseRMarkdownFile = parseRMarkdownFile;
+exports.isRCodeBlock = isRCodeBlock;
+exports.restoreBlocksWithoutMd = restoreBlocksWithoutMd;
+exports.parseCodeBlockOptions = parseCodeBlockOptions;
+const flowr_file_1 = require("../../../context/flowr-file");
+const assert_1 = require("../../../../util/assert");
+const commonmark_1 = require("commonmark");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+/**
+ * This decorates a text file and parses its contents as a R Markdown file.
+ * Finnaly, it provides access to the single cells, and all cells fused together as one R file.
+ */
+class FlowrRMarkdownFile extends flowr_file_1.FlowrFile {
+    data;
+    wrapped;
+    /**
+     * Prefer the static {@link FlowrRMarkdownFile.from} method
+     * @param file - the file to load as R Markdown
+     */
+    constructor(file) {
+        super(file.path(), flowr_file_1.FileRole.Source);
+        this.wrapped = file;
+    }
+    get rmd() {
+        if (!this.data) {
+            this.loadContent();
+        }
+        (0, assert_1.guard)(this.data);
+        return this.data;
+    }
+    /**
+     * Loads and parses the content of the wrapped file.
+     * @returns RmdInfo
+     */
+    loadContent() {
+        this.data = parseRMarkdownFile(this.wrapped.content());
+        return this.data.content;
+    }
+    static from(file) {
+        return file instanceof FlowrRMarkdownFile ? file : new FlowrRMarkdownFile(file);
+    }
+}
+exports.FlowrRMarkdownFile = FlowrRMarkdownFile;
+/**
+ * Parse the contents of a RMarkdown file into complete code and blocks
+ * @param raw - the raw file content
+ * @returns Rmd Info
+ */
+function parseRMarkdownFile(raw) {
+    // Read and Parse Markdown
+    const parser = new commonmark_1.Parser();
+    const ast = parser.parse(raw);
+    // Parse Frontmatter
+    const frontmatter = (0, gray_matter_1.default)(raw);
+    // Parse Codeblocks
+    const walker = ast.walker();
+    const blocks = [];
+    let e;
+    while ((e = walker.next())) {
+        const node = e.node;
+        if (!isRCodeBlock(node)) {
+            continue;
+        }
+        blocks.push({
+            code: node.literal,
+            options: parseCodeBlockOptions(node.info, node.literal),
+            startpos: { line: node.sourcepos[0][0] + 1, col: 0 }
+        });
+    }
+    return {
+        content: restoreBlocksWithoutMd(blocks, countNewlines(raw)),
+        // eslint-disable-next-line unused-imports/no-unused-vars
+        blocks: blocks.map(({ startpos, ...block }) => block),
+        options: frontmatter.data
+    };
+}
+const RTagRegex = /{[rR](?:[\s,][^}]*)?}/;
+/**
+ * Checks whether a CommonMark node is an R code block
+ */
+function isRCodeBlock(node) {
+    return node.type === 'code_block' && node.literal !== null && node.info !== null && RTagRegex.test(node.info);
+}
+const LineRegex = /\r\n|\r|\n/;
+function countNewlines(str) {
+    return str.split(LineRegex).length - 1;
+}
+/**
+ * Restores an Rmd file from code blocks, filling non-code lines with empty lines
+ */
+function restoreBlocksWithoutMd(blocks, totalLines) {
+    let line = 1;
+    let output = '';
+    const goToLine = (n) => {
+        const diff = n - line;
+        (0, assert_1.guard)(diff >= 0);
+        line += diff;
+        output += '\n'.repeat(diff);
+    };
+    for (const block of blocks) {
+        goToLine(block.startpos.line);
+        output += block.code;
+        line += countNewlines(block.code);
+    }
+    // Add remainder of file
+    goToLine(totalLines + 1);
+    return output;
+}
+/**
+ * Parses the options of an R code block from its header and content
+ */
+function parseCodeBlockOptions(header, content) {
+    let opts = header.length === 3 // '{r}' => header.length=3 (no options in header)
+        ? ''
+        : header.substring(3, header.length - 1).trim();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line.trim().startsWith('#|')) {
+            break;
+        }
+        const opt = line.substring(3);
+        opts += opts.length === 0 ? opt : `, ${opt}`;
+    }
+    return opts;
+}
+//# sourceMappingURL=flowr-rmarkdown-file.js.map

package/project/plugins/file-plugins/notebooks/notebook.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=notebook.js.map

package/project/plugins/flowr-analyzer-plugin-defaults.d.ts

@@ -0,0 +1,5 @@
+import type { FlowrAnalyzerPlugin } from './flowr-analyzer-plugin';
+/**
+ * Provides the default set of Flowr Analyzer plugins.
+ */
+export declare function FlowrAnalyzerPluginDefaults(): FlowrAnalyzerPlugin[];

package/project/plugins/flowr-analyzer-plugin-defaults.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPluginDefaults = FlowrAnalyzerPluginDefaults;
+const flowr_analyzer_description_file_plugin_1 = require("./file-plugins/flowr-analyzer-description-file-plugin");
+const flowr_analyzer_package_versions_description_file_plugin_1 = require("./package-version-plugins/flowr-analyzer-package-versions-description-file-plugin");
+const flowr_analyzer_loading_order_description_file_plugin_1 = require("./loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin");
+const flowr_analyzer_rmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-rmd-file-plugin");
+const flowr_analyzer_qmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-qmd-file-plugin");
+const flowr_analyzer_jupyter_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin");
+/**
+ * Provides the default set of Flowr Analyzer plugins.
+ */
+function FlowrAnalyzerPluginDefaults() {
+    return [
+        new flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin(),
+        new flowr_analyzer_package_versions_description_file_plugin_1.FlowrAnalyzerPackageVersionsDescriptionFilePlugin(),
+        new flowr_analyzer_loading_order_description_file_plugin_1.FlowrAnalyzerLoadingOrderDescriptionFilePlugin(),
+        new flowr_analyzer_rmd_file_plugin_1.FlowrAnalyzerRmdFilePlugin(),
+        new flowr_analyzer_qmd_file_plugin_1.FlowrAnalyzerQmdFilePlugin(),
+        new flowr_analyzer_jupyter_file_plugin_1.FlowrAnalyzerJupyterFilePlugin(),
+    ];
+}
+//# sourceMappingURL=flowr-analyzer-plugin-defaults.js.map

package/project/plugins/flowr-analyzer-plugin.d.ts

@@ -72,6 +72,8 @@ export interface FlowrAnalyzerPluginInterface<In = unknown, Out = In> {
  * **Please do not create plugins directly based on this class, but use the classes referenced alongside the {@link PluginType} values!**
  * For example, if you want to create a plugin that determines the loading order of files, extend {@link FlowrAnalyzerLoadingOrderPlugin} instead.
  * These classes also provide sensible overrides of {@link FlowrAnalyzerPlugin.defaultPlugin} to be used when no plugin of this type is registered or triggered.
+ *
+ * For a collection of default plugins, see {@link FlowrAnalyzerPluginDefaults}.
  */
 export declare abstract class FlowrAnalyzerPlugin<In = unknown, Out extends AsyncOrSync<unknown> = In> implements FlowrAnalyzerPluginInterface<In, Out> {
     abstract readonly name: string;

package/project/plugins/flowr-analyzer-plugin.js

@@ -52,6 +52,8 @@ const generalPluginLog = log_1.log.getSubLogger({ name: 'plugins' });
  * **Please do not create plugins directly based on this class, but use the classes referenced alongside the {@link PluginType} values!**
  * For example, if you want to create a plugin that determines the loading order of files, extend {@link FlowrAnalyzerLoadingOrderPlugin} instead.
  * These classes also provide sensible overrides of {@link FlowrAnalyzerPlugin.defaultPlugin} to be used when no plugin of this type is registered or triggered.
+ *
+ * For a collection of default plugins, see {@link FlowrAnalyzerPluginDefaults}.
  */
 class FlowrAnalyzerPlugin {
     /**

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin.js

@@ -15,7 +15,7 @@ class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends flowr_analyzer_load
     description = 'This plugin determines loading order based on the Collate field in DESCRIPTION files.';
     version = new semver_1.SemVer('0.1.0');
     process(ctx) {
-        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.FileRole.Description);
         if (descFiles.length !== 1) {
             flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
             return;

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-description-file-plugin.js

@@ -16,7 +16,7 @@ class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends flowr_analyzer_p
     description = 'This plugin does...';
     version = new semver_1.SemVer('0.1.0');
     process(ctx) {
-        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.FileRole.Description);
         if (descFiles.length !== 1) {
             flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
             return;

package/project/plugins/plugin-registry.d.ts

@@ -0,0 +1,34 @@
+import type { FlowrAnalyzerPlugin } from './flowr-analyzer-plugin';
+import { FlowrAnalyzerDescriptionFilePlugin } from './file-plugins/flowr-analyzer-description-file-plugin';
+import { FlowrAnalyzerPackageVersionsDescriptionFilePlugin } from './package-version-plugins/flowr-analyzer-package-versions-description-file-plugin';
+import { FlowrAnalyzerLoadingOrderDescriptionFilePlugin } from './loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin';
+import { FlowrAnalyzerRmdFilePlugin } from './file-plugins/notebooks/flowr-analyzer-rmd-file-plugin';
+import { FlowrAnalyzerQmdFilePlugin } from './file-plugins/notebooks/flowr-analyzer-qmd-file-plugin';
+import { FlowrAnalyzerJupyterFilePlugin } from './file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin';
+/**
+ * The built-in Flowr Analyzer plugins that are always available.
+ */
+export declare const BuiltInPlugins: [["file:description", typeof FlowrAnalyzerDescriptionFilePlugin], ["versions:description", typeof FlowrAnalyzerPackageVersionsDescriptionFilePlugin], ["loading-order:description", typeof FlowrAnalyzerLoadingOrderDescriptionFilePlugin], ["file:rmd", typeof FlowrAnalyzerRmdFilePlugin], ["file:qmd", typeof FlowrAnalyzerQmdFilePlugin], ["file:ipynb", typeof FlowrAnalyzerJupyterFilePlugin]];
+export type BuiltInFlowrPluginName = typeof BuiltInPlugins[number][0];
+export type BuiltInFlowrPluginArgs<N extends BuiltInFlowrPluginName> = N extends typeof BuiltInPlugins[number][0] ? ConstructorParameters<Extract<typeof BuiltInPlugins[number], [N, PluginProducer]>[1]> : never;
+type PluginProducer = new (...args: never[]) => FlowrAnalyzerPlugin;
+/**
+ * Register a new Flowr Analyzer plugin for the registry,
+ * to be used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer}.
+ */
+export declare function registerPluginMaker(plugin: PluginProducer, name?: Exclude<string, BuiltInFlowrPluginName>): void;
+export declare function getPlugin(name: BuiltInFlowrPluginName, args: BuiltInFlowrPluginArgs<typeof name>): FlowrAnalyzerPlugin;
+export declare function getPlugin(name: string, args?: unknown[]): FlowrAnalyzerPlugin | undefined;
+/**
+ * The type used to register a plugin with the {@link FlowrAnalyzerBuilder}.
+ * @see {@link makePlugin}
+ */
+export type PluginToRegister<T extends BuiltInFlowrPluginName | string> = FlowrAnalyzerPlugin | T | string | (T extends BuiltInFlowrPluginName ? [
+    T,
+    BuiltInFlowrPluginArgs<T>
+] : [string, unknown[]]);
+/**
+ * Create a Flowr Analyzer plugin from a {@link PluginToRegister} specification.
+ */
+export declare function makePlugin<T extends BuiltInFlowrPluginName | string>(toRegister: PluginToRegister<T>): FlowrAnalyzerPlugin;
+export {};

package/project/plugins/plugin-registry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInPlugins = void 0;
+exports.registerPluginMaker = registerPluginMaker;
+exports.getPlugin = getPlugin;
+exports.makePlugin = makePlugin;
+const flowr_analyzer_description_file_plugin_1 = require("./file-plugins/flowr-analyzer-description-file-plugin");
+const flowr_analyzer_package_versions_description_file_plugin_1 = require("./package-version-plugins/flowr-analyzer-package-versions-description-file-plugin");
+const flowr_analyzer_loading_order_description_file_plugin_1 = require("./loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin");
+const flowr_analyzer_rmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-rmd-file-plugin");
+const flowr_analyzer_qmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-qmd-file-plugin");
+const assert_1 = require("../../util/assert");
+const flowr_analyzer_jupyter_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin");
+/**
+ * The built-in Flowr Analyzer plugins that are always available.
+ */
+exports.BuiltInPlugins = [
+    ['file:description', flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin],
+    ['versions:description', flowr_analyzer_package_versions_description_file_plugin_1.FlowrAnalyzerPackageVersionsDescriptionFilePlugin],
+    ['loading-order:description', flowr_analyzer_loading_order_description_file_plugin_1.FlowrAnalyzerLoadingOrderDescriptionFilePlugin],
+    ['file:rmd', flowr_analyzer_rmd_file_plugin_1.FlowrAnalyzerRmdFilePlugin],
+    ['file:qmd', flowr_analyzer_qmd_file_plugin_1.FlowrAnalyzerQmdFilePlugin],
+    ['file:ipynb', flowr_analyzer_jupyter_file_plugin_1.FlowrAnalyzerJupyterFilePlugin],
+];
+/**
+ * The registry of built-in and user-registered Flowr Analyzer plugins.
+ * Used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} to instantiate plugins by name.
+ */
+const PluginRegistry = new Map(exports.BuiltInPlugins);
+/**
+ * Register a new Flowr Analyzer plugin for the registry,
+ * to be used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer}.
+ */
+function registerPluginMaker(plugin, name = plugin.name) {
+    PluginRegistry.set(name, plugin);
+}
+/**
+ * Retrieve a registered Flowr Analyzer plugin by its name.
+ * @see {@link PluginToRegister}
+ */
+function getPlugin(name, args) {
+    const plugin = PluginRegistry.get(name);
+    return plugin ? new plugin(...args) : undefined;
+}
+/**
+ * Create a Flowr Analyzer plugin from a {@link PluginToRegister} specification.
+ */
+function makePlugin(toRegister) {
+    if (toRegister instanceof Object && 'process' in toRegister) {
+        return toRegister;
+    }
+    if (Array.isArray(toRegister)) {
+        const [name, args] = toRegister;
+        const plugin = getPlugin(name, args);
+        (0, assert_1.guard)(plugin !== undefined, () => `Unknown Flowr Analyzer plugin: ${name.toString()}`);
+        return plugin;
+    }
+    const plugin = getPlugin(toRegister, []);
+    (0, assert_1.guard)(plugin !== undefined, () => `Unknown Flowr Analyzer plugin: ${toRegister.toString()}`);
+    return plugin;
+}
+//# sourceMappingURL=plugin-registry.js.map

package/project/plugins/project-discovery/flowr-analyzer-project-discovery-plugin.d.ts

@@ -1,7 +1,7 @@
 import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
 import type { RParseRequest } from '../../../r-bridge/retriever';
 import type { RProjectAnalysisRequest } from '../../context/flowr-analyzer-files-context';
-import type { FlowrFile } from '../../context/flowr-file';
+import { type FlowrFile } from '../../context/flowr-file';
 /**
  * This is the base class for all plugins that discover files in a project for analysis.
  * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project.

package/project/plugins/project-discovery/flowr-analyzer-project-discovery-plugin.js

@@ -19,6 +19,7 @@ class FlowrAnalyzerProjectDiscoveryPlugin extends flowr_analyzer_plugin_1.FlowrA
     }
 }
 exports.FlowrAnalyzerProjectDiscoveryPlugin = FlowrAnalyzerProjectDiscoveryPlugin;
+const discoverRSourcesRegex = /\.(r|rmd|ipynb|qmd)$/i;
 /**
  * This is the default dummy implementation of the {@link FlowrAnalyzerProjectDiscoveryPlugin}.
  * It simply collects all files in the given folder and returns them as either {@link RParseRequest} (for R and Rmd files) or {@link FlowrTextFile} (for all other files).
@@ -27,11 +28,16 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
     name = 'default-project-discovery-plugin';
     description = 'This is the default project discovery plugin that does nothing.';
     version = new semver_1.SemVer('0.0.0');
+    supportedExtensions;
+    constructor(triggerOnExtensions = discoverRSourcesRegex) {
+        super();
+        this.supportedExtensions = triggerOnExtensions;
+    }
     process(_context, args) {
         const requests = [];
         /* the dummy approach of collecting all files, group R and Rmd files, and be done with it */
         for (const file of (0, files_1.getAllFilesSync)(args.content)) {
-            if (file.endsWith('.R') || file.endsWith('.r') || file.endsWith('.Rmd') || file.endsWith('.rmd')) {
+            if (this.supportedExtensions.test(file)) {
                 requests.push({ content: file, request: 'file' });
             }
             else {

package/queries/base-query-format.d.ts

@@ -1,4 +1,4 @@
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -11,5 +11,5 @@ export interface BaseQueryResult {
     readonly '.meta': BaseQueryMeta;
 }
 export interface BasicQueryData {
-    readonly analyzer: FlowrAnalysisProvider;
+    readonly analyzer: ReadonlyFlowrAnalysisProvider;
 }