@zentryc5t/ts-plugin-for-bruno 3.0.6 → 3.2.0

package/out/yamlFiles/maskYamlFileContent.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskYamlCollectionFileContent = maskYamlCollectionFileContent;
+exports.maskYamlFileContent = maskYamlFileContent;
+exports.getScriptContentRanges = getScriptContentRanges;
+const path_1 = require("path");
+const yaml_1 = require("yaml");
+const constants_1 = require("../constants");
+/**
+ * Returns the content of a Yaml file from a Bruno collection the way it should be seen by the Typescript server.
+ *
+ * All characters that are not part of a script's code are replaced by spaces.
+ * Line breaks are kept, so that all offsets and line / character positions are equal to the ones in the original content.
+ * Each script is wrapped in a block (`{ ... }`), so that its declarations are scoped like the ones in code blocks of `.bru` files.
+ *
+ * Only the scripts returned by `getScriptContentRanges` are kept.
+ */
+function maskYamlCollectionFileContent(fileName, fileContent) {
+    const maskedCharacters = maskYamlFileContent(fileContent).split("");
+    const scriptRanges = getScriptContentRanges(fileName, fileContent);
+    let firstFreeIndex = 0;
+    let suffix = "";
+    for (const [index, { start, end }] of scriptRanges.entries()) {
+        const isLastScript = index == scriptRanges.length - 1;
+        const openingBracketIndex = findLastIndexWithoutLineBreak(fileContent, firstFreeIndex, start);
+        const closingBracketIndex = findFirstIndexWithoutLineBreak(fileContent, end, isLastScript ? fileContent.length : scriptRanges[index + 1].start);
+        if (openingBracketIndex == undefined ||
+            (closingBracketIndex == undefined && !isLastScript)) {
+            continue;
+        }
+        for (let i = start; i < end; i++) {
+            maskedCharacters[i] = fileContent[i];
+        }
+        maskedCharacters[openingBracketIndex] = "{";
+        if (closingBracketIndex == undefined) {
+            // Appending characters at the end does not shift any positions.
+            // A line break is needed if the script ends at the end of the file, since the closing bracket could otherwise be part of a line comment.
+            suffix = isLineBreak(fileContent[fileContent.length - 1])
+                ? "}"
+                : "\n}";
+        }
+        else {
+            maskedCharacters[closingBracketIndex] = "}";
+            firstFreeIndex = closingBracketIndex + 1;
+        }
+    }
+    return maskedCharacters.join("").concat(suffix);
+}
+/**
+ * Replaces all characters except for line breaks by spaces, so that the Typescript server does not provide any language features for the file.
+ */
+function maskYamlFileContent(fileContent) {
+    return fileContent.replace(/[^\r\n\u2028\u2029]/g, " ");
+}
+/**
+ * Scripts are defined in `runtime.scripts` for request files and in `request.scripts` for folder and collection settings files.
+ *
+ * The same scripts are returned as by `getScriptBlocksFromYamlFile` in the shared folder of the extension:
+ * Only scripts with a valid type that are defined as literal block scalars (`code: |`) are included.
+ * For all other scalar styles, the raw text in the file is not equal to the code (e.g. due to quotes or line folding).
+ */
+function getScriptContentRanges(fileName, fileContent) {
+    const document = (0, yaml_1.parseDocument)(fileContent);
+    const scripts = document.getIn(isSettingsFile(fileName, document)
+        ? ["request", "scripts"]
+        : ["runtime", "scripts"], true);
+    return ((0, yaml_1.isSeq)(scripts) ? scripts.items : [])
+        .flatMap((script) => {
+        if (!(0, yaml_1.isMap)(script) || !isValidScriptType(script.get("type"))) {
+            return [];
+        }
+        const code = script.get("code", true);
+        if (!(0, yaml_1.isScalar)(code) ||
+            code.type != yaml_1.Scalar.BLOCK_LITERAL ||
+            !code.range) {
+            return [];
+        }
+        const [headerStart, valueEnd] = code.range;
+        const range = getContentRangeForBlockScalar(fileContent, headerStart, valueEnd);
+        return range ? [range] : [];
+    })
+        .sort(({ start: start1 }, { start: start2 }) => start1 - start2);
+}
+/**
+ * Folder settings files are always named `folder.yml`.
+ * The collection settings file is the only file that defines the top-level key `opencollection`.
+ */
+function isSettingsFile(fileName, document) {
+    return (0, path_1.basename)(fileName) == "folder.yml" || document.has("opencollection");
+}
+function isValidScriptType(type) {
+    return Object.values(constants_1.ScriptType).includes(type);
+}
+/**
+ * The range of a block scalar node starts with the header (e.g. `|-`), which is followed by the content on the next lines.
+ */
+function getContentRangeForBlockScalar(fileContent, headerStart, valueEnd) {
+    const lineBreakAfterHeader = /\r\n|\r|\n|\u2028|\u2029/g;
+    lineBreakAfterHeader.lastIndex = headerStart;
+    const match = lineBreakAfterHeader.exec(fileContent);
+    if (!match) {
+        return undefined;
+    }
+    const start = match.index + match[0].length;
+    return start < valueEnd ? { start, end: valueEnd } : undefined;
+}
+function findLastIndexWithoutLineBreak(text, startIndex, endIndexExclusive) {
+    for (let i = endIndexExclusive - 1; i >= startIndex; i--) {
+        if (!isLineBreak(text[i])) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function findFirstIndexWithoutLineBreak(text, startIndex, endIndexExclusive) {
+    for (let i = startIndex; i < endIndexExclusive; i++) {
+        if (!isLineBreak(text[i])) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function isLineBreak(character) {
+    return ["\r", "\n", "\u2028", "\u2029"].includes(character);
+}
+//# sourceMappingURL=maskYamlFileContent.js.map

package/out/yamlFiles/maskYamlFileContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maskYamlFileContent.js","sourceRoot":"","sources":["../../src/yamlFiles/maskYamlFileContent.ts"],"names":[],"mappings":";;AAaA,sEAiDC;AAKD,kDAEC;AASD,wDAmCC;AAjHD,+BAAgC;AAChC,+BAA+E;AAC/E,4CAA0C;AAE1C;;;;;;;;GAQG;AACH,SAAgB,6BAA6B,CACzC,QAAgB,EAChB,WAAmB;IAEnB,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACpE,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACnE,IAAI,cAAc,GAAG,CAAC,CAAC;IACvB,IAAI,MAAM,GAAG,EAAE,CAAC;IAEhB,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;QAC3D,MAAM,YAAY,GAAG,KAAK,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;QAEtD,MAAM,mBAAmB,GAAG,6BAA6B,CACrD,WAAW,EACX,cAAc,EACd,KAAK,CACR,CAAC;QACF,MAAM,mBAAmB,GAAG,8BAA8B,CACtD,WAAW,EACX,GAAG,EACH,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CACpE,CAAC;QAEF,IACI,mBAAmB,IAAI,SAAS;YAChC,CAAC,mBAAmB,IAAI,SAAS,IAAI,CAAC,YAAY,CAAC,EACrD,CAAC;YACC,SAAS;QACb,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/B,gBAAgB,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;QAED,gBAAgB,CAAC,mBAAmB,CAAC,GAAG,GAAG,CAAC;QAE5C,IAAI,mBAAmB,IAAI,SAAS,EAAE,CAAC;YACnC,gEAAgE;YAChE,yIAAyI;YACzI,MAAM,GAAG,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBACrD,CAAC,CAAC,GAAG;gBACL,CAAC,CAAC,KAAK,CAAC;QAChB,CAAC;aAAM,CAAC;YACJ,gBAAgB,CAAC,mBAAmB,CAAC,GAAG,GAAG,CAAC;YAC5C,cAAc,GAAG,mBAAmB,GAAG,CAAC,CAAC;QAC7C,CAAC;IACL,CAAC;IAED,OAAO,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,SAAgB,mBAAmB,CAAC,WAAmB;IACnD,OAAO,WAAW,CAAC,OAAO,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,sBAAsB,CAAC,QAAgB,EAAE,WAAmB;IACxE,MAAM,QAAQ,GAAG,IAAA,oBAAa,EAAC,WAAW,CAAC,CAAC;IAC5C,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAC1B,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC;QAC9B,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC;QACxB,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,EAC5B,IAAI,CACP,CAAC;IAEF,OAAO,CAAC,IAAA,YAAK,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;SACvC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QAChB,IAAI,CAAC,IAAA,YAAK,EAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YAC3D,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAEtC,IACI,CAAC,IAAA,eAAQ,EAAC,IAAI,CAAC;YACf,IAAI,CAAC,IAAI,IAAI,aAAM,CAAC,aAAa;YACjC,CAAC,IAAI,CAAC,KAAK,EACb,CAAC;YACC,OAAO,EAAE,CAAC;QACd,CAAC;QAED,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QAC3C,MAAM,KAAK,GAAG,6BAA6B,CACvC,WAAW,EACX,WAAW,EACX,QAAQ,CACX,CAAC;QAEF,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAChC,CAAC,CAAC;SACD,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AACzE,CAAC;AAED;;;GAGG;AACH,SAAS,cAAc,CAAC,QAAgB,EAAE,QAAkB;IACxD,OAAO,IAAA,eAAQ,EAAC,QAAQ,CAAC,IAAI,YAAY,IAAI,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAa;IACpC,OAAQ,MAAM,CAAC,MAAM,CAAC,sBAAU,CAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,SAAS,6BAA6B,CAClC,WAAmB,EACnB,WAAmB,EACnB,QAAgB;IAEhB,MAAM,oBAAoB,GAAG,2BAA2B,CAAC;IACzD,oBAAoB,CAAC,SAAS,GAAG,WAAW,CAAC;IAC7C,MAAM,KAAK,GAAG,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAErD,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAE5C,OAAO,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED,SAAS,6BAA6B,CAClC,IAAY,EACZ,UAAkB,EAClB,iBAAyB;IAEzB,KAAK,IAAI,CAAC,GAAG,iBAAiB,GAAG,CAAC,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACvD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,OAAO,CAAC,CAAC;QACb,CAAC;IACL,CAAC;IAED,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,SAAS,8BAA8B,CACnC,IAAY,EACZ,UAAkB,EAClB,iBAAyB;IAEzB,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,iBAAiB,EAAE,CAAC,EAAE,EAAE,CAAC;QAClD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,OAAO,CAAC,CAAC;QACb,CAAC;IACL,CAAC;IAED,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,SAAS,WAAW,CAAC,SAAiB;IAClC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AAChE,CAAC"}

package/out/yamlFiles/maskYamlFilesForTypescriptServer.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskYamlFilesForTypescriptServer = maskYamlFilesForTypescriptServer;
+const ts = __importStar(require("typescript/lib/tsserverlibrary"));
+const collectionFormat_1 = require("../collection/collectionFormat");
+const fileContent_1 = require("../fileContent");
+const fileTypes_1 = require("../fileTypes");
+const maskYamlFileContent_1 = require("./maskYamlFileContent");
+/**
+ * The Typescript server parses Yaml files like Typescript files, so that the Yaml content would affect the meaning of the code within scripts.
+ * Therefore, the Typescript server only gets to see the code of scripts within Yaml collection files (see `maskYamlCollectionFileContent`).
+ * All other Yaml files are masked completely. The same applies to Yaml collection files, as long as Yaml collections are not supported.
+ */
+function maskYamlFilesForTypescriptServer(info, configuration) {
+    const host = info.languageServiceHost;
+    // Masking already masked content would remove all scripts.
+    if (fileContent_1.originalSnapshotGettersForHosts.has(host)) {
+        return;
+    }
+    const getOriginalSnapshot = host.getScriptSnapshot.bind(host);
+    const getOriginalScriptVersion = host.getScriptVersion.bind(host);
+    fileContent_1.originalSnapshotGettersForHosts.set(host, getOriginalSnapshot);
+    // A new snapshot is only created, if the content of a file or the configuration changes.
+    let maskedSnapshots = new WeakMap();
+    let configurationVersion = 0;
+    configuration.onDidChange(() => {
+        maskedSnapshots = new WeakMap();
+        configurationVersion++;
+        // The project is not set when the plugin is used without a Typescript server (e.g. in tests).
+        if (info.project) {
+            info.project.refreshDiagnostics();
+        }
+    });
+    // The Typescript server only requests a new snapshot for a file, if the project version and the version of the file change.
+    if (host.getProjectVersion) {
+        const getOriginalProjectVersion = host.getProjectVersion.bind(host);
+        host.getProjectVersion = () => `${getOriginalProjectVersion()}-${configurationVersion}`;
+    }
+    host.getScriptVersion = (fileName) => (0, fileTypes_1.isYamlFile)(fileName)
+        ? `${getOriginalScriptVersion(fileName)}-${configurationVersion}`
+        : getOriginalScriptVersion(fileName);
+    host.getScriptSnapshot = (fileName) => {
+        const originalSnapshot = getOriginalSnapshot(fileName);
+        if (!originalSnapshot || !(0, fileTypes_1.isYamlFile)(fileName)) {
+            return originalSnapshot;
+        }
+        const cachedSnapshot = maskedSnapshots.get(originalSnapshot);
+        if (cachedSnapshot) {
+            return cachedSnapshot;
+        }
+        const originalContent = originalSnapshot.getText(0, originalSnapshot.getLength());
+        // Snapshots created from a string do not support incremental parsing, so the file is always parsed completely.
+        const maskedSnapshot = ts.ScriptSnapshot.fromString(configuration.isYamlCollectionSupportEnabled() &&
+            (0, collectionFormat_1.isFileFromYamlCollection)(info, fileName)
+            ? (0, maskYamlFileContent_1.maskYamlCollectionFileContent)(fileName, originalContent)
+            : (0, maskYamlFileContent_1.maskYamlFileContent)(originalContent));
+        maskedSnapshots.set(originalSnapshot, maskedSnapshot);
+        return maskedSnapshot;
+    };
+}
+//# sourceMappingURL=maskYamlFilesForTypescriptServer.js.map

package/out/yamlFiles/maskYamlFilesForTypescriptServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maskYamlFilesForTypescriptServer.js","sourceRoot":"","sources":["../../src/yamlFiles/maskYamlFilesForTypescriptServer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,4EAqEC;AApFD,mEAAqD;AACrD,qEAA0E;AAC1E,gDAAiE;AACjE,4CAA0C;AAE1C,+DAG+B;AAE/B;;;;GAIG;AACH,SAAgB,gCAAgC,CAC5C,IAAgC,EAChC,aAAkC;IAElC,MAAM,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC;IAEtC,2DAA2D;IAC3D,IAAI,6CAA+B,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,OAAO;IACX,CAAC;IAED,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9D,MAAM,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClE,6CAA+B,CAAC,GAAG,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAC/D,yFAAyF;IACzF,IAAI,eAAe,GAAG,IAAI,OAAO,EAA0C,CAAC;IAC5E,IAAI,oBAAoB,GAAG,CAAC,CAAC;IAE7B,aAAa,CAAC,WAAW,CAAC,GAAG,EAAE;QAC3B,eAAe,GAAG,IAAI,OAAO,EAAE,CAAC;QAChC,oBAAoB,EAAE,CAAC;QACvB,8FAA8F;QAC9F,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC;QACtC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,4HAA4H;IAC5H,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,MAAM,yBAAyB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpE,IAAI,CAAC,iBAAiB,GAAG,GAAG,EAAE,CAC1B,GAAG,yBAAyB,EAAE,IAAI,oBAAoB,EAAE,CAAC;IACjE,CAAC;IAED,IAAI,CAAC,gBAAgB,GAAG,CAAC,QAAQ,EAAE,EAAE,CACjC,IAAA,sBAAU,EAAC,QAAQ,CAAC;QAChB,CAAC,CAAC,GAAG,wBAAwB,CAAC,QAAQ,CAAC,IAAI,oBAAoB,EAAE;QACjE,CAAC,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAE7C,IAAI,CAAC,iBAAiB,GAAG,CAAC,QAAQ,EAAE,EAAE;QAClC,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QAEvD,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAA,sBAAU,EAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,OAAO,gBAAgB,CAAC;QAC5B,CAAC;QAED,MAAM,cAAc,GAAG,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAE7D,IAAI,cAAc,EAAE,CAAC;YACjB,OAAO,cAAc,CAAC;QAC1B,CAAC;QAED,MAAM,eAAe,GAAG,gBAAgB,CAAC,OAAO,CAC5C,CAAC,EACD,gBAAgB,CAAC,SAAS,EAAE,CAC/B,CAAC;QAEF,+GAA+G;QAC/G,MAAM,cAAc,GAAG,EAAE,CAAC,cAAc,CAAC,UAAU,CAC/C,aAAa,CAAC,8BAA8B,EAAE;YAC1C,IAAA,2CAAwB,EAAC,IAAI,EAAE,QAAQ,CAAC;YACxC,CAAC,CAAC,IAAA,mDAA6B,EAAC,QAAQ,EAAE,eAAe,CAAC;YAC1D,CAAC,CAAC,IAAA,yCAAmB,EAAC,eAAe,CAAC,CAC7C,CAAC;QAEF,eAAe,CAAC,GAAG,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAEtD,OAAO,cAAc,CAAC;IAC1B,CAAC,CAAC;AACN,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zentryc5t/ts-plugin-for-bruno",
-    "version": "3.0.6",
+    "version": "3.2.0",
     "main": "./out/index.js",
     "scripts": {
         "compile": "tsc --project tsconfig.json"
@@ -12,9 +12,10 @@
         "url": "git+https://github.com/daniel-b92/bruno-vs-code-extension.git#main"
     },
     "dependencies": {
-        "typescript": "^5.9.2"
+        "typescript": "^6.0.3",
+        "yaml": "^2.9.0"
     },
     "devDependencies": {
-        "@types/node": "^25.7.0"
+        "@types/node": "^26.1.2"
     }
 }

package/src/codeBlocks/bruCodeBlocks.ts

@@ -0,0 +1,66 @@
+import * as ts from "typescript/lib/tsserverlibrary";
+import { CodeBlockName } from "../constants";
+
+export function getCodeBlockIndizesForBruFile(fileContent: string) {
+    const indizes: {
+        blockName: string;
+        startIndex: number;
+        endIndex: number;
+    }[] = [];
+
+    for (const blockName of Object.values(CodeBlockName)) {
+        const indizesForBlock = getCodeBlockStartAndEndIndex(
+            fileContent,
+            blockName,
+        );
+
+        if (indizesForBlock) {
+            indizes.push({ blockName, ...indizesForBlock });
+        }
+    }
+
+    return indizes;
+}
+
+function getCodeBlockStartAndEndIndex(
+    fullTextContent: string,
+    blockName: CodeBlockName,
+) {
+    const openingBracketChar = "{";
+
+    const startPattern = new RegExp(
+        `^\\s*${blockName}\\s*${openingBracketChar}\\s*$`,
+        "m",
+    );
+    const startMatches = startPattern.exec(fullTextContent);
+
+    if (!startMatches || startMatches.length == 0) {
+        return undefined;
+    }
+
+    const blockStartIndex = startMatches.index;
+    const remainingDoc = fullTextContent.substring(blockStartIndex);
+
+    const sourceFile = ts.createSourceFile(
+        "test.js",
+        remainingDoc,
+        ts.ScriptTarget.ES2020,
+    );
+
+    const blockNodeInSubDocument = (sourceFile as ts.Node)
+        .getChildAt(0, sourceFile)
+        .getChildren(sourceFile)
+        .find(({ kind }) => kind == ts.SyntaxKind.Block);
+
+    if (!blockNodeInSubDocument) {
+        throw new Error(
+            `Could not find code block within given subdocument: ${remainingDoc}`,
+        );
+    }
+
+    return {
+        startIndex:
+            blockStartIndex + startMatches[0].indexOf(openingBracketChar) + 1,
+        endIndex: blockStartIndex + blockNodeInSubDocument.end,
+    };
+}

package/src/codeChanges/codeChanges.ts

@@ -0,0 +1,182 @@
+import * as ts from "typescript/lib/tsserverlibrary";
+import { getCodeBlockIndizesForBruFile } from "../codeBlocks/bruCodeBlocks";
+import { isFileFromYamlCollection } from "../collection/collectionFormat";
+import { getOriginalFileContent } from "../fileContent";
+import { hasEmbeddedCodeBlocks, isBruFile } from "../fileTypes";
+import { getIndentationOfScripts } from "../yamlFiles/getIndentationOfScripts";
+import { getScriptContentRanges } from "../yamlFiles/maskYamlFileContent";
+
+/**
+ * The Typescript server indents the top-level statements of scripts in Yaml files relative to column 0,
+ * since each script is wrapped in a block that is not indented (see `maskYamlCollectionFileContent`).
+ * Inserted lines (e.g. when extracting a constant) would therefore end the Yaml block scalar.
+ * To avoid this, the base indentation is set to the indentation of the scripts minus one indentation level for the wrapping block.
+ */
+export function getFormatOptionsForFile(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+    formatOptions: ts.FormatCodeSettings,
+    range: { start: number; end: number },
+): ts.FormatCodeSettings {
+    if (!isFileFromYamlCollection(info, fileName)) {
+        return formatOptions;
+    }
+
+    const originalContent = getOriginalFileContent(info, fileName);
+    const scriptIndentation = originalContent
+        ? getIndentationOfScripts(fileName, originalContent, range)
+        : undefined;
+    const indentSize =
+        formatOptions.indentSize ??
+        ts.getDefaultFormatCodeSettings().indentSize!;
+
+    if (scriptIndentation == undefined || scriptIndentation < indentSize) {
+        return formatOptions;
+    }
+
+    return {
+        ...formatOptions,
+        baseIndentSize: scriptIndentation - indentSize,
+        // Tabs are not allowed for indenting Yaml content.
+        convertTabsToSpaces: true,
+    };
+}
+
+interface CodeRange {
+    start: number;
+    end: number;
+}
+
+interface OriginalFile {
+    content: string;
+    contentOutsideOfCode: string[];
+    getCodeRanges: (fileContent: string) => CodeRange[];
+}
+
+/**
+ * Returns a function that checks whether the given changes only modify the code within code blocks, if they affect '.bru' or '.yml' files.
+ *
+ * The returned function determines the data for the original content of each file only once,
+ * since the changes of many code fixes usually affect the same file.
+ */
+export function createCheckForChangesWithinCodeBlocks(
+    info: ts.server.PluginCreateInfo,
+) {
+    const originalFiles = new Map<string, OriginalFile | undefined>();
+
+    return (changes: readonly ts.FileTextChanges[]) =>
+        changes.every(({ fileName, textChanges, isNewFile }) => {
+            if (!hasEmbeddedCodeBlocks(fileName)) {
+                return true;
+            } else if (isNewFile) {
+                return false;
+            }
+
+            if (!originalFiles.has(fileName)) {
+                originalFiles.set(fileName, getOriginalFile(info, fileName));
+            }
+
+            const originalFile = originalFiles.get(fileName);
+
+            if (!originalFile) {
+                return false;
+            }
+
+            const { content, contentOutsideOfCode, getCodeRanges } =
+                originalFile;
+            const modifiedContent = applyTextChanges(content, textChanges);
+
+            // Comparing the content outside of code blocks also detects changes that end a code block early,
+            // e.g. an inserted line within a Yaml block scalar that is not indented enough.
+            const modifiedContentOutsideOfCode = getContentOutsideOfCodeRanges(
+                modifiedContent,
+                getCodeRanges(modifiedContent),
+            );
+
+            return (
+                contentOutsideOfCode.length ==
+                    modifiedContentOutsideOfCode.length &&
+                contentOutsideOfCode.every(
+                    (part, index) =>
+                        part == modifiedContentOutsideOfCode[index],
+                )
+            );
+        });
+}
+
+function getOriginalFile(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+): OriginalFile | undefined {
+    const content = getOriginalFileContent(info, fileName);
+
+    if (!content) {
+        return undefined;
+    }
+
+    const getCodeRanges = isBruFile(fileName)
+        ? getCodeRangesForBruFile
+        : isFileFromYamlCollection(info, fileName)
+          ? (fileContent: string) =>
+                getScriptContentRanges(fileName, fileContent)
+          : () => [];
+
+    return {
+        content,
+        contentOutsideOfCode: getContentOutsideOfCodeRanges(
+            content,
+            getCodeRanges(content),
+        ),
+        getCodeRanges,
+    };
+}
+
+function getCodeRangesForBruFile(fileContent: string): CodeRange[] {
+    return getCodeBlockIndizesForBruFile(fileContent)
+        .map(({ startIndex, endIndex }) => ({
+            start: startIndex,
+            end: endIndex - 1, // index of the closing bracket
+        }))
+        .sort(({ start: start1 }, { start: start2 }) => start1 - start2);
+}
+
+function getContentOutsideOfCodeRanges(
+    fileContent: string,
+    codeRanges: CodeRange[],
+) {
+    return codeRanges
+        .map(({ start }, index) =>
+            fileContent.substring(
+                index == 0 ? 0 : codeRanges[index - 1].end,
+                start,
+            ),
+        )
+        .concat(
+            fileContent.substring(
+                codeRanges.length > 0
+                    ? codeRanges[codeRanges.length - 1].end
+                    : 0,
+            ),
+        );
+}
+
+/**
+ * The text changes for a file do not overlap and their spans refer to the original content.
+ */
+function applyTextChanges(
+    fileContent: string,
+    textChanges: readonly ts.TextChange[],
+) {
+    return [...textChanges]
+        .sort(
+            ({ span: { start: start1 } }, { span: { start: start2 } }) =>
+                start2 - start1,
+        )
+        .reduce(
+            (content, { span: { start, length }, newText }) =>
+                content.substring(0, start) +
+                newText +
+                content.substring(start + length),
+            fileContent,
+        );
+}

package/src/collection/collectionFormat.ts

@@ -0,0 +1,96 @@
+import { dirname, extname } from "path";
+import * as ts from "typescript/lib/tsserverlibrary";
+import { CollectionFormat } from "../constants";
+
+export function isInABrunoCollection(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+) {
+    return getFormatOfContainingCollection(info, fileName) != undefined;
+}
+
+/**
+ * Collection files in the Yaml format always use the extension `.yml`.
+ */
+export function isFileFromYamlCollection(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+) {
+    return (
+        extname(fileName) == ".yml" &&
+        getFormatOfContainingCollection(info, fileName) == CollectionFormat.Yaml
+    );
+}
+
+function getFormatOfContainingCollection(
+    info: ts.server.PluginCreateInfo,
+    fileName: string,
+) {
+    let currentDirectory = dirname(fileName);
+    let format = getFormatIfCollectionRootFolder(info, currentDirectory);
+
+    while (
+        info.serverHost.directoryExists(currentDirectory) &&
+        !format &&
+        dirname(currentDirectory) != currentDirectory // dirname of a base folder in the file system seems to return the input folder again
+    ) {
+        currentDirectory = dirname(currentDirectory);
+        format = getFormatIfCollectionRootFolder(info, currentDirectory);
+    }
+
+    return format;
+}
+
+function getFormatIfCollectionRootFolder(
+    info: ts.server.PluginCreateInfo,
+    directoryPath: string,
+) {
+    const collectionRootFile = info.serverHost
+        .readDirectory(directoryPath, undefined, undefined, undefined, 1)
+        .find((fileName) => {
+            const isBruCollectionRootFile = fileName.endsWith("bruno.json");
+            const isYamlCollectionRootFile =
+                fileName.endsWith("opencollection.yml");
+
+            if (!isBruCollectionRootFile && !isYamlCollectionRootFile) {
+                return false;
+            }
+
+            const content = info.languageServiceHost.readFile(fileName);
+
+            if (!content) {
+                return false;
+            }
+
+            return isBruCollectionRootFile
+                ? isBrunoJsonForCollection(content)
+                : isOpenCollectionRootFileContent(content);
+        });
+
+    if (!collectionRootFile) {
+        return undefined;
+    }
+
+    return collectionRootFile.endsWith("bruno.json")
+        ? CollectionFormat.Bru
+        : CollectionFormat.Yaml;
+}
+
+function isBrunoJsonForCollection(content: string) {
+    try {
+        const parsedContent = JSON.parse(content) as
+            { type: string } | undefined;
+
+        return parsedContent && parsedContent.type == "collection";
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Request, folder and environment files can be named `opencollection.yml` as well.
+ * Only the actual collection root file defines the top-level key `opencollection`.
+ */
+function isOpenCollectionRootFileContent(content: string) {
+    return /^opencollection\s*:/m.test(content);
+}

package/src/constants.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from "@jest/globals";
+import { ScriptType as ScriptTypeFromExtension } from "../../shared/fileParsing/external/yamlFormat/constants/sharedConstants";
+import { ScriptType } from "./constants";
+
+describe("ScriptType", () => {
+    // The plugin is published as a separate package, so it cannot import the constants from the extension.
+    it("is equal to the script types known to the extension", () => {
+        expect(Object.values(ScriptType)).toEqual(
+            Object.values(ScriptTypeFromExtension),
+        );
+    });
+});

package/src/constants.ts

@@ -0,0 +1,31 @@
+export enum CollectionFormat {
+    Bru = "bru",
+    Yaml = "yaml",
+}
+
+export enum CodeBlockName {
+    Tests = "tests",
+    PreRequestScript = "script:pre-request",
+    PostResponseScript = "script:post-response",
+    GrpcBeforeCallStartScript = "script:grpc:before-call-start",
+    GrpcBeforeMessageSendScript = "script:grpc:before-message-send",
+    GrpcAfterMessageReceiveScript = "script:grpc:after-message-receive",
+    GrpcAfterCallEndScript = "script:grpc:after-call-end",
+}
+
+export function getTempJsFileBaseNameWithoutExtension() {
+    return "__temp_bru_reference";
+}
+
+export function getNamesForInbuiltRuntimeVarsAndFunctions() {
+    return ["bru", "req", "res", "test", "expect"];
+}
+
+/**
+ * Same as `ScriptType` for Yaml files in the shared folder of the extension.
+ */
+export enum ScriptType {
+    BeforeRequest = "before-request",
+    AfterResponse = "after-response",
+    Tests = "tests",
+}