norn-cli 2.3.0 → 2.4.0

package/out/nornapiParser.js

@@ -0,0 +1,324 @@
+"use strict";
+/**
+ * Parser for .nornapi files
+ *
+ * Parses header groups and endpoint definitions from .nornapi files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNornApiFile = parseNornApiFile;
+exports.getHeaderGroup = getHeaderGroup;
+exports.getEndpoint = getEndpoint;
+exports.resolveEndpointPath = resolveEndpointPath;
+exports.resolveHeaderValues = resolveHeaderValues;
+exports.isApiRequestLine = isApiRequestLine;
+exports.parseApiRequest = parseApiRequest;
+const parser_1 = require("./parser");
+/**
+ * Extracts parameter names from an endpoint path
+ * e.g., /users/{id}/orders/{orderId} -> ['id', 'orderId']
+ *
+ * Note: Does NOT extract {{variable}} references (double braces) - only {param} (single braces)
+ */
+function extractPathParameters(path) {
+    const params = [];
+    // Match {param} but NOT {{variable}}
+    // Use negative lookbehind (?<!{) and negative lookahead (?!})
+    const regex = /(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*)\}(?!\})/g;
+    let match;
+    while ((match = regex.exec(path)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}
+/**
+ * Parses a .nornapi file and returns header groups and endpoint definitions
+ */
+function parseNornApiFile(content) {
+    const lines = content.split('\n');
+    const headerGroups = [];
+    const endpoints = [];
+    let currentHeaderGroup = null;
+    let inEndpointsBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Check for headers block start: headers Name
+        const headersStartMatch = trimmed.match(/^headers\s+([a-zA-Z_][a-zA-Z0-9_]*)$/i);
+        if (headersStartMatch) {
+            currentHeaderGroup = {
+                name: headersStartMatch[1],
+                headers: {}
+            };
+            continue;
+        }
+        // Check for headers block end
+        if (/^end\s+headers$/i.test(trimmed)) {
+            if (currentHeaderGroup) {
+                headerGroups.push(currentHeaderGroup);
+                currentHeaderGroup = null;
+            }
+            continue;
+        }
+        // Inside headers block - parse header lines
+        if (currentHeaderGroup) {
+            const headerMatch = trimmed.match(/^([a-zA-Z][a-zA-Z0-9\-]*)\s*:\s*(.+)$/);
+            if (headerMatch) {
+                currentHeaderGroup.headers[headerMatch[1]] = headerMatch[2].trim();
+            }
+            continue;
+        }
+        // Check for endpoints block start
+        if (/^endpoints$/i.test(trimmed)) {
+            inEndpointsBlock = true;
+            continue;
+        }
+        // Check for endpoints block end
+        if (/^end\s+endpoints$/i.test(trimmed)) {
+            inEndpointsBlock = false;
+            continue;
+        }
+        // Inside endpoints block - parse endpoint lines
+        // Format: EndpointName: METHOD /path/{param}
+        if (inEndpointsBlock) {
+            const endpointMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+            if (endpointMatch) {
+                const path = endpointMatch[3].trim();
+                endpoints.push({
+                    name: endpointMatch[1],
+                    method: endpointMatch[2].toUpperCase(),
+                    path,
+                    parameters: extractPathParameters(path)
+                });
+            }
+            continue;
+        }
+    }
+    return { headerGroups, endpoints };
+}
+/**
+ * Gets a header group by name (case-sensitive)
+ */
+function getHeaderGroup(definition, name) {
+    return definition.headerGroups.find(hg => hg.name === name);
+}
+/**
+ * Gets an endpoint by name (case-sensitive)
+ */
+function getEndpoint(definition, name) {
+    return definition.endpoints.find(ep => ep.name === name);
+}
+/**
+ * Resolves an endpoint path with provided parameters
+ * e.g., path: /users/{id}/orders, params: { id: '123' } -> /users/123/orders
+ */
+function resolveEndpointPath(endpoint, params) {
+    let resolvedPath = endpoint.path;
+    for (const paramName of endpoint.parameters) {
+        const value = params[paramName];
+        if (value !== undefined) {
+            resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
+        }
+    }
+    return resolvedPath;
+}
+/**
+ * Applies variable substitution to header values
+ */
+function resolveHeaderValues(headerGroup, variables) {
+    const resolved = {};
+    for (const [name, value] of Object.entries(headerGroup.headers)) {
+        resolved[name] = (0, parser_1.substituteVariables)(value, variables);
+    }
+    return resolved;
+}
+/**
+ * Checks if a request line uses endpoint syntax instead of a URL
+ * Endpoint syntax: METHOD EndpointName(param, ...) [HeaderGroups...]
+ * URL syntax: METHOD http://... or METHOD /path
+ *
+ * Returns true if the URL part starts with a word that matches an endpoint name
+ */
+function isApiRequestLine(requestContent, endpoints) {
+    const lines = requestContent.split('\n');
+    // Find the first non-empty, non-comment, non-import line
+    let firstLine = '';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('import ')) {
+            firstLine = trimmed;
+            break;
+        }
+    }
+    if (!firstLine) {
+        return false;
+    }
+    // Match METHOD followed by non-URL pattern
+    const match = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)/i);
+    if (!match) {
+        return false;
+    }
+    const potentialEndpointName = match[2];
+    // Check if this matches a known endpoint
+    return endpoints.some(ep => ep.name === potentialEndpointName);
+}
+/**
+ * Parses an API request block (endpoint-based syntax)
+ *
+ * Handles two syntax styles:
+ * 1. Single line: GET GetUser("123") Auth Json
+ * 2. Multi-line:
+ *    GET GetUser("123")
+ *    Auth
+ *    Json
+ *
+ * Returns parsed information or undefined if not an API request
+ */
+function parseApiRequest(requestContent, endpoints, headerGroups) {
+    const lines = requestContent.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#') && !l.startsWith('import '));
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const firstLine = lines[0];
+    // Parse: METHOD EndpointName(params...) [HeaderGroups...]
+    // Params can be: positional values or key=value pairs
+    const lineMatch = firstLine.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]*)\))?\s*(.*)$/i);
+    if (!lineMatch) {
+        return undefined;
+    }
+    const methodFromLine = lineMatch[1].toUpperCase();
+    const endpointName = lineMatch[2];
+    const paramsStr = lineMatch[3] || '';
+    const headerGroupsOnLine = lineMatch[4]?.trim() || '';
+    // Find the endpoint
+    const endpoint = endpoints.find(ep => ep.name === endpointName);
+    if (!endpoint) {
+        return undefined;
+    }
+    // Verify the method matches (or allow method from line to override)
+    // Actually, the user might use a different method - we use the line's method
+    const method = methodFromLine;
+    // Parse parameters: positional or key=value
+    const params = {};
+    if (paramsStr) {
+        // Split by comma, respecting quotes
+        const paramTokens = parseParamTokens(paramsStr);
+        // Check if key=value or positional
+        if (paramTokens.length > 0 && paramTokens[0].includes(':')) {
+            // Key=value format: GetUser(id: "123")
+            for (const token of paramTokens) {
+                const kvMatch = token.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+                if (kvMatch) {
+                    params[kvMatch[1]] = unquote(kvMatch[2].trim());
+                }
+            }
+        }
+        else {
+            // Positional format: GetUser("123") -> map to endpoint parameters in order
+            for (let i = 0; i < paramTokens.length && i < endpoint.parameters.length; i++) {
+                params[endpoint.parameters[i]] = unquote(paramTokens[i].trim());
+            }
+        }
+    }
+    // Collect header group names and inline headers
+    const headerGroupNames = [];
+    const inlineHeaders = {};
+    // From same line
+    if (headerGroupsOnLine) {
+        const names = headerGroupsOnLine.split(/\s+/).filter(n => n);
+        for (const name of names) {
+            if (headerGroups.some(hg => hg.name === name)) {
+                headerGroupNames.push(name);
+            }
+        }
+    }
+    // From subsequent lines:
+    // - Header group names (single word matching a defined group)
+    // - Inline headers (HeaderName: value format)
+    // - Body content (everything else after headers section)
+    const bodyLines = [];
+    let inBodySection = false;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        // Once we start the body section, everything goes to body
+        if (inBodySection) {
+            bodyLines.push(line);
+            continue;
+        }
+        // Check if this line is a header group name
+        if (headerGroups.some(hg => hg.name === line)) {
+            headerGroupNames.push(line);
+            continue;
+        }
+        // Check if this is an inline header (HeaderName: value)
+        const headerMatch = line.match(/^([a-zA-Z][a-zA-Z0-9\-]*)\s*:\s*(.+)$/);
+        if (headerMatch) {
+            let headerValue = headerMatch[2].trim();
+            // Remove surrounding quotes if present
+            if ((headerValue.startsWith('"') && headerValue.endsWith('"')) ||
+                (headerValue.startsWith("'") && headerValue.endsWith("'"))) {
+                headerValue = headerValue.slice(1, -1);
+            }
+            inlineHeaders[headerMatch[1]] = headerValue;
+            continue;
+        }
+        // Not a header group or inline header - start of body section
+        inBodySection = true;
+        bodyLines.push(line);
+    }
+    const body = bodyLines.length > 0 ? bodyLines.join('\n') : undefined;
+    return {
+        method,
+        endpointName,
+        params,
+        headerGroupNames,
+        inlineHeaders,
+        body
+    };
+}
+/**
+ * Splits parameter string by commas, respecting quotes
+ */
+function parseParamTokens(paramsStr) {
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+    for (const char of paramsStr) {
+        if ((char === '"' || char === "'") && !inQuote) {
+            inQuote = true;
+            quoteChar = char;
+            current += char;
+        }
+        else if (char === quoteChar && inQuote) {
+            inQuote = false;
+            quoteChar = '';
+            current += char;
+        }
+        else if (char === ',' && !inQuote) {
+            tokens.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    return tokens;
+}
+/**
+ * Removes surrounding quotes from a string value
+ */
+function unquote(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+//# sourceMappingURL=nornapiParser.js.map

package/out/nornenvCodeActionProvider.js

@@ -0,0 +1,101 @@
+"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.NornenvCodeActionProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const nornenvLanguageModel_1 = require("./nornenvLanguageModel");
+function levenshteinDistance(left, right) {
+    const a = left.toLowerCase();
+    const b = right.toLowerCase();
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const current = Array.from({ length: b.length + 1 }, () => 0);
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + cost);
+        }
+        for (let j = 0; j <= b.length; j++) {
+            previous[j] = current[j];
+        }
+    }
+    return previous[b.length];
+}
+function closestName(name, candidates) {
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const distance = levenshteinDistance(name, candidate);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = candidate;
+        }
+    }
+    return bestDistance <= (name.length <= 5 ? 1 : 2) ? best : undefined;
+}
+class NornenvCodeActionProvider {
+    static providedCodeActionKinds = [vscode.CodeActionKind.QuickFix];
+    provideCodeActions(document, _range, context) {
+        const actions = [];
+        const unknownParentDiagnostics = context.diagnostics.filter(diagnostic => diagnostic.code === 'unknown-extends-parent');
+        if (unknownParentDiagnostics.length === 0) {
+            return actions;
+        }
+        let candidates;
+        try {
+            const filePath = document.uri.scheme === 'file' ? document.uri.fsPath : undefined;
+            const config = (0, nornenvLanguageModel_1.loadResolvedNornenvConfigFromText)(document.getText(), filePath);
+            candidates = config.templates.map(template => template.name);
+        }
+        catch {
+            return actions;
+        }
+        for (const diagnostic of unknownParentDiagnostics) {
+            const unknownName = document.getText(diagnostic.range);
+            const suggestion = closestName(unknownName, candidates);
+            if (!suggestion) {
+                continue;
+            }
+            const action = new vscode.CodeAction(`Replace '${unknownName}' with '${suggestion}'`, vscode.CodeActionKind.QuickFix);
+            action.diagnostics = [diagnostic];
+            action.edit = new vscode.WorkspaceEdit();
+            action.edit.replace(document.uri, diagnostic.range, suggestion);
+            actions.push(action);
+        }
+        return actions;
+    }
+}
+exports.NornenvCodeActionProvider = NornenvCodeActionProvider;
+//# sourceMappingURL=nornenvCodeActionProvider.js.map

package/out/nornenvDecorationProvider.js

@@ -0,0 +1,239 @@
+"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.NornenvDecorationProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const environmentParser_1 = require("./environmentParser");
+const environmentProvider_1 = require("./environmentProvider");
+const nornenvLanguageModel_1 = require("./nornenvLanguageModel");
+// Norn brand palette — keep in sync with `norn_website/src/styles/global.css`
+// (`.file-pill.norn / .nornsql / .nornenv`) so editor chips match website chips.
+const BRAND_TEAL = '#4ec9b0';
+const BRAND_BLUE = '#569cd6';
+const BRAND_AMBER = '#d7ba7d';
+const BRAND_PURPLE = '#c586c0';
+const BRAND_TEAL_SUBTLE = 'rgba(78, 201, 176, 0.15)';
+const BRAND_TEAL_BORDER = 'rgba(78, 201, 176, 0.35)';
+const BRAND_AMBER_SUBTLE = 'rgba(215, 186, 125, 0.15)';
+const BRAND_AMBER_BORDER = 'rgba(215, 186, 125, 0.35)';
+const BRAND_PURPLE_SUBTLE = 'rgba(197, 134, 192, 0.15)';
+const BRAND_PURPLE_BORDER = 'rgba(197, 134, 192, 0.35)';
+/**
+ * Builds an `after.contentText` decoration with proper margin spacing for the *first*
+ * chip on a line, and (for the rest) chained tightly so each new chip just adds a
+ * separator dot and the chip text.
+ *
+ * VS Code does not let us set per-chip background colors via a single
+ * `after.contentText`, so each chip kind gets its own `TextEditorDecorationType`.
+ * Multiple decorations stack at the end of the line in registration order.
+ */
+class NornenvDecorationProvider {
+    countChipDecoration;
+    inheritedChipDecoration;
+    overridesChipDecoration;
+    activeChipDecoration;
+    cycleChipDecoration;
+    unknownParentChipDecoration;
+    envParentChipDecoration;
+    environmentSubscription;
+    constructor() {
+        // `N vars` — neutral muted count.
+        // Leading spacing comes from per-instance contentText so the *first* non-pill
+        // chip on a line gets the gap regardless of which kind it happens to be.
+        // (The `extends X, Y` chip used to live here; it was pure noise because the same
+        // text already appears in the section header immediately to the left.)
+        this.countChipDecoration = vscode.window.createTextEditorDecorationType({
+            after: {
+                color: new vscode.ThemeColor('descriptionForeground'),
+                fontStyle: 'italic'
+            }
+        });
+        // `N inherited` — brand blue (matches website's .nornapi pill text)
+        this.inheritedChipDecoration = vscode.window.createTextEditorDecorationType({
+            after: {
+                color: BRAND_BLUE,
+                fontStyle: 'italic'
+            }
+        });
+        // `N overrides` — brand teal (the "self-contribution" color)
+        this.overridesChipDecoration = vscode.window.createTextEditorDecorationType({
+            after: {
+                color: BRAND_TEAL,
+                fontStyle: 'italic'
+            }
+        });
+        // Active pill — subtle teal-on-teal (.file-pill.norn from the website).
+        // The `border` field's value is serialized verbatim into the inline `style`
+        // attribute, so we smuggle padding + border-radius through trailing semicolons.
+        this.activeChipDecoration = this.createSubtlePillDecoration(BRAND_TEAL, BRAND_TEAL_SUBTLE, BRAND_TEAL_BORDER);
+        // Error pills — subtle purple-on-purple (.file-pill.nornenv): cycle, env-as-parent
+        this.cycleChipDecoration = this.createSubtlePillDecoration(BRAND_PURPLE, BRAND_PURPLE_SUBTLE, BRAND_PURPLE_BORDER);
+        this.envParentChipDecoration = this.createSubtlePillDecoration(BRAND_PURPLE, BRAND_PURPLE_SUBTLE, BRAND_PURPLE_BORDER);
+        // Warning pill — subtle amber-on-amber (.file-pill.nornsql): unknown parent
+        this.unknownParentChipDecoration = this.createSubtlePillDecoration(BRAND_AMBER, BRAND_AMBER_SUBTLE, BRAND_AMBER_BORDER);
+        this.environmentSubscription = (0, environmentProvider_1.onDidChangeActiveEnvironment)(() => {
+            this.updateVisibleEditors();
+        });
+    }
+    /**
+     * Pastel pill matching the website's `.file-pill.<lang>` styling:
+     * subtle-tinted background + colored text + 35%-alpha border, fully rounded.
+     * `font-weight: 500` to match the website pill's weight.
+     */
+    createSubtlePillDecoration(textColor, backgroundColor, borderColor) {
+        return vscode.window.createTextEditorDecorationType({
+            after: {
+                color: textColor,
+                backgroundColor,
+                border: `1px solid ${borderColor}; border-radius: 100px; padding: 0 8px; margin: 0 0 0 8px; font-weight: 500;`,
+                fontStyle: 'normal'
+            }
+        });
+    }
+    updateVisibleEditors() {
+        for (const editor of vscode.window.visibleTextEditors) {
+            this.update(editor);
+        }
+    }
+    update(editor) {
+        if (!editor || (editor.document.languageId !== 'nornenv' && !editor.document.uri.fsPath.endsWith('.nornenv'))) {
+            return;
+        }
+        try {
+            const text = editor.document.getText();
+            const filePath = editor.document.uri.scheme === 'file' ? editor.document.uri.fsPath : undefined;
+            const config = (0, nornenvLanguageModel_1.loadResolvedNornenvConfigFromText)(text, filePath);
+            const model = (0, nornenvLanguageModel_1.parseNornenvDocumentModel)(text);
+            const activeEnvironment = (0, environmentProvider_1.getActiveEnvironment)(filePath);
+            const cycles = new Set((0, environmentParser_1.detectExtendsCycles)(config).flatMap(cycle => cycle.path));
+            const sectionChips = model.sections.map(section => ({
+                section,
+                chips: this.buildChips(section, config, cycles, activeEnvironment)
+            }));
+            // For each chip kind, build the DecorationOptions[] for the lines that need it.
+            // Each chip on a line gets a separator dot from the previous chip's text — except
+            // the first chip in this line, which gets a leading margin via the decoration type.
+            const optionsByKind = {
+                count: [],
+                inherited: [],
+                overrides: [],
+                active: [],
+                cycle: [],
+                'unknown-parent': [],
+                'env-parent': []
+            };
+            for (const { section, chips } of sectionChips) {
+                const line = editor.document.lineAt(section.lineNumber);
+                const endOfLine = new vscode.Range(section.lineNumber, line.text.length, section.lineNumber, line.text.length);
+                for (let index = 0; index < chips.length; index++) {
+                    const chip = chips[index];
+                    const isFirstOnLine = index === 0;
+                    // Pills (active / warnings) carry their own left margin via the border CSS
+                    // hack, so they never need the separator dot. Non-pill chips need a leading
+                    // gap when they're the first on the line — otherwise they slam into `]`.
+                    const isPill = chip.kind === 'active' || chip.kind === 'cycle' || chip.kind === 'unknown-parent' || chip.kind === 'env-parent';
+                    const separator = isFirstOnLine ? '   ' : ' · ';
+                    const contentText = isPill ? chip.text : `${separator}${chip.text}`;
+                    optionsByKind[chip.kind].push({
+                        range: endOfLine,
+                        renderOptions: {
+                            after: { contentText }
+                        }
+                    });
+                }
+            }
+            editor.setDecorations(this.countChipDecoration, optionsByKind.count);
+            editor.setDecorations(this.inheritedChipDecoration, optionsByKind.inherited);
+            editor.setDecorations(this.overridesChipDecoration, optionsByKind.overrides);
+            editor.setDecorations(this.activeChipDecoration, optionsByKind.active);
+            editor.setDecorations(this.cycleChipDecoration, optionsByKind.cycle);
+            editor.setDecorations(this.unknownParentChipDecoration, optionsByKind['unknown-parent']);
+            editor.setDecorations(this.envParentChipDecoration, optionsByKind['env-parent']);
+        }
+        catch {
+            const emptyDecorations = [];
+            editor.setDecorations(this.countChipDecoration, emptyDecorations);
+            editor.setDecorations(this.inheritedChipDecoration, emptyDecorations);
+            editor.setDecorations(this.overridesChipDecoration, emptyDecorations);
+            editor.setDecorations(this.activeChipDecoration, emptyDecorations);
+            editor.setDecorations(this.cycleChipDecoration, emptyDecorations);
+            editor.setDecorations(this.unknownParentChipDecoration, emptyDecorations);
+            editor.setDecorations(this.envParentChipDecoration, emptyDecorations);
+        }
+    }
+    buildChips(section, config, cycles, activeEnvironment) {
+        const found = (0, environmentParser_1.findExtendsNode)(section.name, config);
+        const ownVariables = found ? Object.keys(found.node.variables) : [];
+        const inherited = (0, environmentParser_1.resolveInheritedVariableDetails)(section.name, config);
+        const ancestorOrCommonNames = new Set([
+            ...Object.keys(config.common),
+            ...(0, environmentParser_1.collectAncestorVariableNames)(section.name, config)
+        ]);
+        const overrides = ownVariables.filter(name => ancestorOrCommonNames.has(name)).length;
+        const chips = [];
+        chips.push({ kind: 'count', text: `${ownVariables.length} vars` });
+        if (inherited.size > 0) {
+            chips.push({ kind: 'inherited', text: `${inherited.size} inherited` });
+        }
+        if (overrides > 0) {
+            chips.push({ kind: 'overrides', text: `${overrides} overrides` });
+        }
+        if (section.kind === 'env' && section.name === activeEnvironment) {
+            chips.push({ kind: 'active', text: 'Active' });
+        }
+        if (section.parents.some(parent => config.environments.some(env => env.name === parent) && !(0, environmentParser_1.findExtendsTemplate)(parent, config))) {
+            chips.push({ kind: 'env-parent', text: '! env parent' });
+        }
+        else if (section.parents.some(parent => !(0, environmentParser_1.findExtendsTemplate)(parent, config))) {
+            chips.push({ kind: 'unknown-parent', text: '! unknown parent' });
+        }
+        if (cycles.has(section.name)) {
+            chips.push({ kind: 'cycle', text: '! cycle' });
+        }
+        return chips;
+    }
+    dispose() {
+        this.environmentSubscription.dispose();
+        this.countChipDecoration.dispose();
+        this.inheritedChipDecoration.dispose();
+        this.overridesChipDecoration.dispose();
+        this.activeChipDecoration.dispose();
+        this.cycleChipDecoration.dispose();
+        this.unknownParentChipDecoration.dispose();
+        this.envParentChipDecoration.dispose();
+    }
+}
+exports.NornenvDecorationProvider = NornenvDecorationProvider;
+//# sourceMappingURL=nornenvDecorationProvider.js.map