norn-cli 2.3.0 → 2.4.0

package/out/nornInlayHintsProvider.js

@@ -0,0 +1,191 @@
+"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.NornInlayHintsProvider = void 0;
+exports.buildNornScopeIndex = buildNornScopeIndex;
+exports.getInScopeDecls = getInScopeDecls;
+exports.findEnclosingSequence = findEnclosingSequence;
+exports.buildScopedVariablesAtLine = buildScopedVariablesAtLine;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+const sequenceRunner_1 = require("./sequenceRunner");
+const inlayHintResolver_1 = require("./inlayHintResolver");
+const TEMPLATE_TOKEN_REGEX = /\{\{([^{}]+)\}\}/g;
+// `var name = <expr>` — captures the bare name and the trimmed right-hand side.
+const VAR_DECL_REGEX = /^\s*var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+?)\s*$/;
+// Values that come from runtime sources we can't evaluate at edit time.
+const RUNTIME_VALUE_REGEX = /^(\$\d+|run\s|POST\s|GET\s|PUT\s|DELETE\s|PATCH\s|HEAD\s|OPTIONS\s)/i;
+const QUOTED_STRING_REGEX = /^"([^"\\]*(?:\\.[^"\\]*)*)"$/;
+function parseVarDecl(line, lineNumber, scope, sequenceName) {
+    const match = line.match(VAR_DECL_REGEX);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1];
+    const rawValue = match[2].trim();
+    if (RUNTIME_VALUE_REGEX.test(rawValue)) {
+        return { name, rawValue, lineNumber, scope, sequenceName, isRuntime: true };
+    }
+    const quoted = rawValue.match(QUOTED_STRING_REGEX);
+    const staticValue = quoted ? quoted[1].replace(/\\"/g, '"').replace(/\\\\/g, '\\') : rawValue;
+    return { name, rawValue, lineNumber, scope, sequenceName, isRuntime: false, staticValue };
+}
+/**
+ * Walks the `.norn` document and indexes every `var` declaration into the right scope.
+ * File-level vars are anything before the first sequence; sequence-local vars belong to
+ * the enclosing `[test ]sequence X` / `end sequence` block.
+ */
+function buildNornScopeIndex(text) {
+    const lines = text.split('\n');
+    const sequences = (0, sequenceRunner_1.extractSequences)(text);
+    const decls = [];
+    const sequenceBoundaries = new Map();
+    // Build a line→sequence lookup using extractSequences's startLine + lines array length.
+    const lineToSequence = new Map();
+    for (const seq of sequences) {
+        const startLine = seq.startLine
+            ?? seq.lineNumber
+            ?? 0;
+        const lineCount = seq.lines?.length ?? 1;
+        const endLine = startLine + lineCount - 1;
+        sequenceBoundaries.set(seq.name, { startLine, endLine });
+        for (let i = startLine; i <= endLine; i++) {
+            lineToSequence.set(i, seq.name);
+        }
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const sequenceName = lineToSequence.get(i);
+        const scope = sequenceName ? 'sequence-local' : 'file-local';
+        const decl = parseVarDecl(lines[i], i, scope, sequenceName);
+        if (decl) {
+            decls.push(decl);
+        }
+    }
+    return { decls, sequenceBoundaries };
+}
+/**
+ * For a given line, returns the var declarations that are in scope and visible at this point:
+ *  - All file-level vars (regardless of position; they're top-of-file conceptually).
+ *  - Sequence-local vars declared *before* `lineNumber` in the *same* enclosing sequence.
+ */
+function getInScopeDecls(index, lineNumber) {
+    const enclosingSequence = findEnclosingSequence(index, lineNumber);
+    return index.decls.filter(decl => {
+        if (decl.scope === 'file-local') {
+            return decl.lineNumber < lineNumber;
+        }
+        if (decl.scope === 'sequence-local') {
+            return decl.sequenceName === enclosingSequence && decl.lineNumber < lineNumber;
+        }
+        return false;
+    });
+}
+function findEnclosingSequence(index, lineNumber) {
+    for (const [name, { startLine, endLine }] of index.sequenceBoundaries) {
+        if (lineNumber >= startLine && lineNumber <= endLine) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/**
+ * Builds the merged variables map for a given line in a `.norn` file:
+ *   env (common + ancestor chain + self) ← file-locals ← sequence-locals.
+ * Runtime-only vars are deliberately omitted — references to them stay unresolvable
+ * so the inlay layer skips them silently.
+ */
+function buildScopedVariablesAtLine(envVariables, index, lineNumber) {
+    const merged = { ...envVariables };
+    for (const decl of getInScopeDecls(index, lineNumber)) {
+        if (decl.isRuntime || decl.staticValue === undefined) {
+            continue;
+        }
+        merged[decl.name] = decl.staticValue;
+    }
+    return merged;
+}
+class NornInlayHintsProvider {
+    emitter = new vscode.EventEmitter();
+    environmentSubscription;
+    onDidChangeInlayHints = this.emitter.event;
+    constructor() {
+        this.environmentSubscription = (0, environmentProvider_1.onDidChangeActiveEnvironment)(() => {
+            this.emitter.fire();
+        });
+    }
+    provideInlayHints(document, range) {
+        const hints = [];
+        try {
+            const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+            if (!filePath) {
+                return [];
+            }
+            const config = (0, environmentProvider_1.loadEnvironmentConfig)(filePath);
+            const envVariables = config ? (0, environmentProvider_1.getEnvironmentVariables)(filePath) : {};
+            const secretNames = config?.secretNames ?? new Set();
+            const index = buildNornScopeIndex(document.getText());
+            for (let lineNumber = range.start.line; lineNumber <= range.end.line; lineNumber++) {
+                const line = document.lineAt(lineNumber).text;
+                if (!line.includes('{{')) {
+                    continue;
+                }
+                const variables = buildScopedVariablesAtLine(envVariables, index, lineNumber);
+                TEMPLATE_TOKEN_REGEX.lastIndex = 0;
+                for (const match of line.matchAll(TEMPLATE_TOKEN_REGEX)) {
+                    const resolved = (0, inlayHintResolver_1.resolveInlayValueLabel)(match[1], variables, secretNames);
+                    if (!resolved) {
+                        continue;
+                    }
+                    const tokenEnd = (match.index ?? 0) + match[0].length;
+                    const hint = new vscode.InlayHint(new vscode.Position(lineNumber, tokenEnd), resolved.label, vscode.InlayHintKind.Parameter);
+                    hint.tooltip = resolved.secret
+                        ? `'${match[1].trim()}' resolves from a secret value.`
+                        : `'${match[1].trim()}' resolves to '${resolved.value}'.`;
+                    hints.push(hint);
+                }
+            }
+        }
+        catch {
+            return [];
+        }
+        return hints;
+    }
+    dispose() {
+        this.environmentSubscription.dispose();
+        this.emitter.dispose();
+    }
+}
+exports.NornInlayHintsProvider = NornInlayHintsProvider;
+//# sourceMappingURL=nornInlayHintsProvider.js.map