parse-hcl 0.1.0

package/dist/utils/lexer/hclLexer.js

@@ -0,0 +1,525 @@
+"use strict";
+/**
+ * Shared lexer utilities for HCL parsing.
+ * Provides common functions for tokenization and string handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isQuote = isQuote;
+exports.isEscaped = isEscaped;
+exports.skipWhitespaceAndComments = skipWhitespaceAndComments;
+exports.skipString = skipString;
+exports.skipHeredoc = skipHeredoc;
+exports.findMatchingBrace = findMatchingBrace;
+exports.findMatchingBracket = findMatchingBracket;
+exports.readIdentifier = readIdentifier;
+exports.readDottedIdentifier = readDottedIdentifier;
+exports.readQuotedString = readQuotedString;
+exports.readValue = readValue;
+exports.splitArrayElements = splitArrayElements;
+exports.splitObjectEntries = splitObjectEntries;
+/**
+ * Checks if a character is a quote character (single or double).
+ * @param char - The character to check
+ * @returns True if the character is a quote
+ */
+function isQuote(char) {
+    return char === '"' || char === "'";
+}
+/**
+ * Checks if a character at a given position is escaped by counting preceding backslashes.
+ * Handles consecutive backslashes correctly (e.g., \\\\ is two escaped backslashes).
+ * @param text - The source text
+ * @param index - The index of the character to check
+ * @returns True if the character is escaped
+ */
+function isEscaped(text, index) {
+    let backslashCount = 0;
+    let pos = index - 1;
+    while (pos >= 0 && text[pos] === '\\') {
+        backslashCount++;
+        pos--;
+    }
+    return backslashCount % 2 === 1;
+}
+/**
+ * Skips whitespace and comments (line and block comments).
+ * Handles "//", block comments, and "#" style comments.
+ * @param text - The source text
+ * @param start - The starting index
+ * @returns The index of the next non-whitespace, non-comment character
+ */
+function skipWhitespaceAndComments(text, start) {
+    let index = start;
+    const length = text.length;
+    while (index < length) {
+        const char = text[index];
+        const next = text[index + 1];
+        // Skip whitespace
+        if (/\s/.test(char)) {
+            index++;
+            continue;
+        }
+        // Skip block comments /* ... */
+        if (char === '/' && next === '*') {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? length : end + 2;
+            continue;
+        }
+        // Skip line comments // ...
+        if (char === '/' && next === '/') {
+            const end = text.indexOf('\n', index + 2);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        // Skip hash comments # ...
+        if (char === '#') {
+            const end = text.indexOf('\n', index + 1);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+/**
+ * Skips a quoted string, handling escape sequences correctly.
+ * @param text - The source text
+ * @param start - The index of the opening quote
+ * @returns The index after the closing quote
+ */
+function skipString(text, start) {
+    const quote = text[start];
+    let index = start + 1;
+    const length = text.length;
+    while (index < length) {
+        const char = text[index];
+        if (char === quote && !isEscaped(text, index)) {
+            return index + 1;
+        }
+        index++;
+    }
+    return length;
+}
+/**
+ * Skips a heredoc string (<<EOF or <<-EOF style).
+ * @param text - The source text
+ * @param start - The index of the first '<'
+ * @returns The index after the heredoc terminator
+ */
+function skipHeredoc(text, start) {
+    const markerMatch = text.slice(start).match(/^<<-?\s*"?([A-Za-z0-9_]+)"?/);
+    if (!markerMatch) {
+        return start + 2;
+    }
+    const marker = markerMatch[1];
+    const afterMarker = start + markerMatch[0].length;
+    const terminatorIndex = text.indexOf(`\n${marker}`, afterMarker);
+    if (terminatorIndex === -1) {
+        return text.length;
+    }
+    const endOfTerminator = text.indexOf('\n', terminatorIndex + marker.length + 1);
+    return endOfTerminator === -1 ? text.length : endOfTerminator + 1;
+}
+/**
+ * Finds the matching closing brace for an opening brace.
+ * Handles nested braces, strings, comments, and heredocs.
+ * @param content - The source text
+ * @param startIndex - The index of the opening brace
+ * @returns The index of the matching closing brace, or -1 if not found
+ */
+function findMatchingBrace(content, startIndex) {
+    let depth = 0;
+    let index = startIndex;
+    const length = content.length;
+    while (index < length) {
+        const char = content[index];
+        const next = content[index + 1];
+        // Skip quoted strings
+        if (isQuote(char)) {
+            index = skipString(content, index);
+            continue;
+        }
+        // Skip block comments
+        if (char === '/' && next === '*') {
+            const end = content.indexOf('*/', index + 2);
+            index = end === -1 ? length : end + 2;
+            continue;
+        }
+        // Skip line comments
+        if (char === '/' && next === '/') {
+            const end = content.indexOf('\n', index + 2);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        // Skip hash comments
+        if (char === '#') {
+            const end = content.indexOf('\n', index + 1);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        // Skip heredocs
+        if (char === '<' && next === '<') {
+            index = skipHeredoc(content, index);
+            continue;
+        }
+        // Track brace depth
+        if (char === '{') {
+            depth++;
+        }
+        else if (char === '}') {
+            depth--;
+            if (depth === 0) {
+                return index;
+            }
+        }
+        index++;
+    }
+    return -1;
+}
+/**
+ * Finds the matching closing bracket for an opening bracket.
+ * Handles nested brackets of all types [], {}, ().
+ * @param content - The source text
+ * @param startIndex - The index of the opening bracket
+ * @param openChar - The opening bracket character
+ * @param closeChar - The closing bracket character
+ * @returns The index of the matching closing bracket, or -1 if not found
+ */
+function findMatchingBracket(content, startIndex, openChar, closeChar) {
+    let depth = 0;
+    let index = startIndex;
+    const length = content.length;
+    while (index < length) {
+        const char = content[index];
+        const next = content[index + 1];
+        // Skip quoted strings
+        if (isQuote(char)) {
+            index = skipString(content, index);
+            continue;
+        }
+        // Skip block comments
+        if (char === '/' && next === '*') {
+            const end = content.indexOf('*/', index + 2);
+            index = end === -1 ? length : end + 2;
+            continue;
+        }
+        // Skip line comments
+        if (char === '/' && next === '/') {
+            const end = content.indexOf('\n', index + 2);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        // Skip hash comments
+        if (char === '#') {
+            const end = content.indexOf('\n', index + 1);
+            index = end === -1 ? length : end + 1;
+            continue;
+        }
+        // Track bracket depth
+        if (char === openChar) {
+            depth++;
+        }
+        else if (char === closeChar) {
+            depth--;
+            if (depth === 0) {
+                return index;
+            }
+        }
+        index++;
+    }
+    return -1;
+}
+/**
+ * Reads an identifier from the source text.
+ * Identifiers start with a letter or underscore, followed by letters, digits, underscores, or hyphens.
+ * @param text - The source text
+ * @param start - The starting index
+ * @returns The identifier string, or empty string if no identifier found
+ */
+function readIdentifier(text, start) {
+    const match = text.slice(start).match(/^[A-Za-z_][\w-]*/);
+    return match ? match[0] : '';
+}
+/**
+ * Reads an identifier that may contain dots (for attribute access).
+ * @param text - The source text
+ * @param start - The starting index
+ * @returns The identifier string, or empty string if no identifier found
+ */
+function readDottedIdentifier(text, start) {
+    const match = text.slice(start).match(/^[\w.-]+/);
+    return match ? match[0] : '';
+}
+/**
+ * Reads a quoted string and returns its unescaped content.
+ * @param text - The source text
+ * @param start - The index of the opening quote
+ * @returns The unquoted string and the index after the closing quote
+ */
+function readQuotedString(text, start) {
+    const quote = text[start];
+    let index = start + 1;
+    let value = '';
+    const length = text.length;
+    while (index < length) {
+        const char = text[index];
+        if (char === quote && !isEscaped(text, index)) {
+            return { text: value, end: index + 1 };
+        }
+        // Handle escape sequences
+        if (char === '\\' && index + 1 < length) {
+            const nextChar = text[index + 1];
+            if (nextChar === quote || nextChar === '\\' || nextChar === 'n' || nextChar === 't' || nextChar === 'r') {
+                switch (nextChar) {
+                    case 'n':
+                        value += '\n';
+                        break;
+                    case 't':
+                        value += '\t';
+                        break;
+                    case 'r':
+                        value += '\r';
+                        break;
+                    default:
+                        value += nextChar;
+                }
+                index += 2;
+                continue;
+            }
+        }
+        value += char;
+        index++;
+    }
+    return { text: value, end: length };
+}
+/**
+ * Reads a value from HCL source (handles multiline values in brackets).
+ * @param text - The source text
+ * @param start - The starting index (after the '=' sign)
+ * @returns The raw value text and the index after the value
+ */
+function readValue(text, start) {
+    let index = skipWhitespaceAndComments(text, start);
+    const valueStart = index;
+    const length = text.length;
+    // Handle heredocs
+    if (text.slice(index, index + 2) === '<<') {
+        const newlineIndex = text.indexOf('\n', index);
+        const firstLine = newlineIndex === -1 ? text.slice(index) : text.slice(index, newlineIndex);
+        const markerMatch = firstLine.match(/^<<-?\s*"?([A-Za-z0-9_]+)"?/);
+        if (markerMatch) {
+            const marker = markerMatch[1];
+            const terminatorIndex = text.indexOf(`\n${marker}`, newlineIndex);
+            if (terminatorIndex !== -1) {
+                const endOfTerminator = text.indexOf('\n', terminatorIndex + marker.length + 1);
+                const endIndex = endOfTerminator === -1 ? length : endOfTerminator;
+                return { raw: text.slice(valueStart, endIndex).trim(), end: endIndex };
+            }
+        }
+    }
+    // Track bracket depth for multiline values
+    let depth = 0;
+    let inString = false;
+    let stringChar = null;
+    while (index < length) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (!inString) {
+            // Enter string
+            if (isQuote(char)) {
+                inString = true;
+                stringChar = char;
+                index++;
+                continue;
+            }
+            // Skip block comments
+            if (char === '/' && next === '*') {
+                const end = text.indexOf('*/', index + 2);
+                index = end === -1 ? length : end + 2;
+                continue;
+            }
+            // Skip line comments
+            if (char === '/' && next === '/') {
+                const end = text.indexOf('\n', index + 2);
+                index = end === -1 ? length : end + 1;
+                continue;
+            }
+            // Track brackets
+            if (char === '{' || char === '[' || char === '(') {
+                depth++;
+            }
+            else if (char === '}' || char === ']' || char === ')') {
+                depth = Math.max(depth - 1, 0);
+            }
+            // End of value (newline at depth 0)
+            if ((char === '\n' || char === '\r') && depth === 0) {
+                break;
+            }
+        }
+        else {
+            // Exit string
+            if (char === stringChar && !isEscaped(text, index)) {
+                inString = false;
+                stringChar = null;
+            }
+        }
+        index++;
+    }
+    return { raw: text.slice(valueStart, index).trim(), end: index };
+}
+/**
+ * Splits an array literal into its elements.
+ * Handles nested arrays, objects, and strings correctly.
+ * @param raw - The raw array string including brackets
+ * @returns Array of raw element strings
+ */
+function splitArrayElements(raw) {
+    const inner = raw.slice(1, -1).trim();
+    if (!inner) {
+        return [];
+    }
+    const elements = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    let stringChar = null;
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (!inString) {
+            if (isQuote(char)) {
+                inString = true;
+                stringChar = char;
+                current += char;
+                continue;
+            }
+            if (char === '{' || char === '[' || char === '(') {
+                depth++;
+                current += char;
+                continue;
+            }
+            if (char === '}' || char === ']' || char === ')') {
+                depth--;
+                current += char;
+                continue;
+            }
+            if (char === ',' && depth === 0) {
+                const trimmed = current.trim();
+                if (trimmed) {
+                    elements.push(trimmed);
+                }
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        else {
+            current += char;
+            if (char === stringChar && !isEscaped(inner, i)) {
+                inString = false;
+                stringChar = null;
+            }
+        }
+    }
+    const trimmed = current.trim();
+    if (trimmed) {
+        elements.push(trimmed);
+    }
+    return elements;
+}
+/**
+ * Splits an object literal into key-value pairs.
+ * Handles nested objects, arrays, and strings correctly.
+ * @param raw - The raw object string including braces
+ * @returns Array of [key, value] tuples
+ */
+function splitObjectEntries(raw) {
+    const inner = raw.slice(1, -1).trim();
+    if (!inner) {
+        return [];
+    }
+    const entries = [];
+    let index = 0;
+    const length = inner.length;
+    while (index < length) {
+        index = skipWhitespaceAndComments(inner, index);
+        if (index >= length)
+            break;
+        // Read key (can be identifier or quoted string)
+        let key;
+        if (isQuote(inner[index])) {
+            const result = readQuotedString(inner, index);
+            key = result.text;
+            index = result.end;
+        }
+        else {
+            key = readDottedIdentifier(inner, index);
+            index += key.length;
+        }
+        if (!key) {
+            index++;
+            continue;
+        }
+        index = skipWhitespaceAndComments(inner, index);
+        // Expect = or :
+        if (inner[index] === '=' || inner[index] === ':') {
+            index++;
+        }
+        // Read value
+        const valueResult = readObjectValue(inner, index);
+        entries.push([key, valueResult.raw]);
+        index = valueResult.end;
+        // Skip comma if present
+        index = skipWhitespaceAndComments(inner, index);
+        if (inner[index] === ',') {
+            index++;
+        }
+    }
+    return entries;
+}
+/**
+ * Reads a value within an object (stops at comma or closing brace).
+ */
+function readObjectValue(text, start) {
+    let index = skipWhitespaceAndComments(text, start);
+    const valueStart = index;
+    const length = text.length;
+    let depth = 0;
+    let inString = false;
+    let stringChar = null;
+    while (index < length) {
+        const char = text[index];
+        if (!inString) {
+            if (isQuote(char)) {
+                inString = true;
+                stringChar = char;
+                index++;
+                continue;
+            }
+            if (char === '{' || char === '[' || char === '(') {
+                depth++;
+                index++;
+                continue;
+            }
+            if (char === '}' || char === ']' || char === ')') {
+                if (depth === 0) {
+                    break;
+                }
+                depth--;
+                index++;
+                continue;
+            }
+            if ((char === ',' || char === '\n') && depth === 0) {
+                break;
+            }
+            index++;
+        }
+        else {
+            if (char === stringChar && !isEscaped(text, index)) {
+                inString = false;
+                stringChar = null;
+            }
+            index++;
+        }
+    }
+    return { raw: text.slice(valueStart, index).trim(), end: index };
+}

package/dist/utils/parser/bodyParser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parser for HCL block bodies.
+ * Extracts attributes (key = value pairs) and nested blocks from block content.
+ */
+import { ParsedBody } from '../../types/blocks';
+/**
+ * Parses an HCL block body into structured attributes and nested blocks.
+ *
+ * @param body - The raw block body content (without outer braces)
+ * @returns ParsedBody containing attributes and nested blocks
+ *
+ * @example
+ * ```typescript
+ * const body = `
+ *   name = "example"
+ *   count = 5
+ *   tags {
+ *     env = "prod"
+ *   }
+ * `;
+ * const parsed = parseBlockBody(body);
+ * // parsed.attributes: { name: Value, count: Value }
+ * // parsed.blocks: [{ type: 'tags', ... }]
+ * ```
+ */
+export declare function parseBlockBody(body: string): ParsedBody;

package/dist/utils/parser/bodyParser.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Parser for HCL block bodies.
+ * Extracts attributes (key = value pairs) and nested blocks from block content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBlockBody = parseBlockBody;
+const valueClassifier_1 = require("./valueClassifier");
+const hclLexer_1 = require("../lexer/hclLexer");
+/**
+ * Parses an HCL block body into structured attributes and nested blocks.
+ *
+ * @param body - The raw block body content (without outer braces)
+ * @returns ParsedBody containing attributes and nested blocks
+ *
+ * @example
+ * ```typescript
+ * const body = `
+ *   name = "example"
+ *   count = 5
+ *   tags {
+ *     env = "prod"
+ *   }
+ * `;
+ * const parsed = parseBlockBody(body);
+ * // parsed.attributes: { name: Value, count: Value }
+ * // parsed.blocks: [{ type: 'tags', ... }]
+ * ```
+ */
+function parseBlockBody(body) {
+    const attributes = {};
+    const blocks = [];
+    let index = 0;
+    const length = body.length;
+    while (index < length) {
+        index = (0, hclLexer_1.skipWhitespaceAndComments)(body, index);
+        if (index >= length)
+            break;
+        const identifierStart = index;
+        const identifier = (0, hclLexer_1.readDottedIdentifier)(body, index);
+        if (!identifier) {
+            index++;
+            continue;
+        }
+        index += identifier.length;
+        index = (0, hclLexer_1.skipWhitespaceAndComments)(body, index);
+        // Check for attribute assignment (key = value)
+        if (body[index] === '=') {
+            const { raw, end } = (0, hclLexer_1.readValue)(body, index + 1);
+            attributes[identifier] = (0, valueClassifier_1.classifyValue)(raw);
+            index = end;
+            continue;
+        }
+        // Check for nested block with labels
+        const labels = [];
+        while ((0, hclLexer_1.isQuote)(body[index])) {
+            const { text, end } = (0, hclLexer_1.readQuotedString)(body, index);
+            labels.push(text);
+            index = (0, hclLexer_1.skipWhitespaceAndComments)(body, end);
+        }
+        // Check for nested block opening brace
+        if (body[index] === '{') {
+            const closeIndex = (0, hclLexer_1.findMatchingBrace)(body, index);
+            const innerBody = body.slice(index + 1, closeIndex);
+            const parsed = parseBlockBody(innerBody);
+            const raw = body.slice(identifierStart, closeIndex + 1);
+            blocks.push({
+                type: identifier,
+                labels,
+                attributes: parsed.attributes,
+                blocks: parsed.blocks,
+                raw
+            });
+            index = closeIndex + 1;
+            continue;
+        }
+        // Not recognized, skip character and continue
+        index++;
+    }
+    return { attributes, blocks };
+}

package/dist/utils/parser/valueClassifier.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Value classifier for HCL expressions.
+ * Classifies raw value strings into typed Value structures and extracts references.
+ */
+import { Value } from '../../types/blocks';
+/**
+ * Classifies a raw HCL value string into a typed Value structure.
+ * Supports literals, quoted strings, arrays, objects, and expressions.
+ *
+ * @param raw - The raw value string to classify
+ * @returns The classified Value with type information and extracted references
+ *
+ * @example
+ * ```typescript
+ * classifyValue('true')           // LiteralValue { type: 'literal', value: true }
+ * classifyValue('"hello"')        // LiteralValue { type: 'literal', value: 'hello' }
+ * classifyValue('var.region')     // ExpressionValue with variable reference
+ * classifyValue('[1, 2, 3]')      // ArrayValue with parsed elements
+ * ```
+ */
+export declare function classifyValue(raw: string): Value;