@eagleoutice/flowr 2.4.7 → 2.5.0

package/util/formats/adapters/r-adapter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAdapter = void 0;
+exports.RAdapter = {
+    convertRequest: (request) => request
+};
+//# sourceMappingURL=r-adapter.js.map

package/util/formats/adapters/rmd-adapter.d.ts

@@ -0,0 +1,26 @@
+import type { Node } from 'commonmark';
+import type { RParseRequest, RParseRequestFromText } from '../../../r-bridge/retriever';
+export interface CodeBlock {
+    options: string;
+    code: string;
+}
+export type CodeBlockEx = CodeBlock & {
+    startpos: {
+        line: number;
+        col: number;
+    };
+};
+export interface RmdInfo {
+    type: 'Rmd';
+    blocks: CodeBlock[];
+    options: object;
+}
+export declare const RmdAdapter: {
+    convertRequest: (request: RParseRequest) => RParseRequestFromText<RmdInfo>;
+};
+export declare function isRCodeBlock(node: Node): node is Node & {
+    literal: string;
+    info: string;
+};
+export declare function restoreBlocksWithoutMd(blocks: CodeBlockEx[], totalLines: number): string;
+export declare function parseCodeBlockOptions(header: string, content: string): string;

package/util/formats/adapters/rmd-adapter.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RmdAdapter = void 0;
+exports.isRCodeBlock = isRCodeBlock;
+exports.restoreBlocksWithoutMd = restoreBlocksWithoutMd;
+exports.parseCodeBlockOptions = parseCodeBlockOptions;
+const fs_1 = __importDefault(require("fs"));
+const commonmark_1 = require("commonmark");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const assert_1 = require("../../assert");
+exports.RmdAdapter = {
+    convertRequest: (request) => {
+        // Read and Parse Markdown
+        const raw = request.request === 'text'
+            ? request.content
+            : fs_1.default.readFileSync(request.content, 'utf-8').toString();
+        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 {
+            request: 'text',
+            content: restoreBlocksWithoutMd(blocks, countNewlines(raw)),
+            info: {
+                // eslint-disable-next-line unused-imports/no-unused-vars
+                blocks: blocks.map(({ startpos, ...block }) => block),
+                options: frontmatter.data,
+                type: 'Rmd'
+            }
+        };
+    }
+};
+const RTagRegex = /{[rR](?:[\s,][^}]*)?}/;
+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;
+}
+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;
+}
+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=rmd-adapter.js.map

package/util/objects.d.ts

@@ -10,12 +10,23 @@ type OrReadonly<T> = T | Readonly<T> | DeepReadonly<T>;
 /**
  * Given two objects deeply merges them, if an object is an array it will merge the array values!
  * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
+ *
+ * @see {@link deepMergeObjectInPlace} to merge into an existing object
  */
 export declare function deepMergeObject<T extends Mergeable>(base: Required<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
 export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
 export declare function deepMergeObject<T extends Mergeable>(base: OrReadonly<T>, addon?: DeepPartial<T> | Partial<T>): T;
 export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
 export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;
+/**
+ * Given two objects deeply merges them, if an object is an array it will merge the array values!
+ * Modifies the `base` object in place and also returns it.
+ * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
+ *
+ * @see {@link deepMergeObject} to create a new merged object
+ */
+export declare function deepMergeObjectInPlace<T extends Mergeable>(base: T, addon?: DeepPartial<T> | Partial<T>): T;
+export declare function deepMergeObjectInPlace<T extends Mergeable>(base: T | undefined, addon?: DeepPartial<T> | Partial<T>): T | undefined;
 type Defined<T> = Exclude<T, undefined>;
 type DefinedRecord<T> = {
     [K in keyof T as T[K] extends undefined ? never : K]: Defined<T[K]>;

package/util/objects.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isObjectOrArray = isObjectOrArray;
 exports.deepMergeObject = deepMergeObject;
+exports.deepMergeObjectInPlace = deepMergeObjectInPlace;
 exports.compactRecord = compactRecord;
 const json_1 = require("./json");
 /**
@@ -56,6 +57,31 @@ function deepMergeObjectWithResult(addon, base, result) {
         }
     }
 }
+function deepMergeObjectInPlace(base, addon) {
+    if (!base) {
+        return addon;
+    }
+    else if (!addon) {
+        return base;
+    }
+    else if (typeof base !== 'object' || typeof addon !== 'object') {
+        // this case should be guarded by type guards, but in case we do not know
+        throw new Error('illegal types for deepMergeObjectInPlace!');
+    }
+    assertSameType(base, addon);
+    const baseIsArray = Array.isArray(base);
+    const addonIsArray = Array.isArray(addon);
+    if (!baseIsArray && !addonIsArray) {
+        deepMergeObjectWithResult(addon, base, base);
+    }
+    else if (baseIsArray && addonIsArray) {
+        (base).push(...addon);
+    }
+    else {
+        throw new Error('cannot merge object with array!');
+    }
+    return base;
+}
 function assertSameType(base, addon) {
     if (base !== undefined && addon !== undefined && typeof base !== typeof addon) {
         throw new Error(`cannot merge different types! ${typeof base} (${JSON.stringify(base, json_1.jsonReplacer)}) !== ${typeof addon} (${JSON.stringify(addon, json_1.jsonReplacer)})`);

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.4.7';
+const version = '2.5.0';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }