@chilts/weave 0.1.0

package/dist/lexer/index.js

@@ -0,0 +1,679 @@
+export class LexerError extends Error {
+    line;
+    col;
+    constructor(message, line, col) {
+        super(`${message} at line ${line}, col ${col}`);
+        this.name = 'LexerError';
+        this.line = line;
+        this.col = col;
+    }
+}
+// Keywords that are recognized at the start of a line.
+// Each must be followed by a space, '(', or end-of-line to be treated as a keyword.
+const KEYWORDS = new Set([
+    'import',
+    'template',
+    'mixin',
+    'extends',
+    'block',
+    'include',
+    'doctype',
+    'if',
+    'for',
+]);
+class Lexer {
+    lines;
+    lineIndex = 0;
+    pos = 0;
+    currentLine = '';
+    indentWidth = 0; // leading spaces of current line
+    indentStack = [0];
+    tokens = [];
+    constructor(source) {
+        this.lines = source.split('\n');
+    }
+    lex() {
+        for (this.lineIndex = 0; this.lineIndex < this.lines.length; this.lineIndex++) {
+            const rawLine = this.lines[this.lineIndex];
+            // Skip blank lines (empty or whitespace-only)
+            if (rawLine.trim().length === 0) {
+                continue;
+            }
+            // Measure indentation
+            this.indentWidth = this.measureIndent(rawLine);
+            this.currentLine = rawLine.slice(this.indentWidth);
+            this.pos = 0;
+            // Emit INDENT/DEDENT tokens
+            this.emitIndentation(this.indentWidth);
+            // Dispatch based on line content
+            this.processLine();
+            // Emit NEWLINE
+            this.emit('NEWLINE', '');
+        }
+        // Close any remaining indentation
+        while (this.indentStack.length > 1) {
+            this.indentStack.pop();
+            this.emit('DEDENT', '');
+        }
+        this.emit('EOF', '');
+        return this.tokens;
+    }
+    measureIndent(line) {
+        let indent = 0;
+        for (let i = 0; i < line.length; i++) {
+            if (line[i] === ' ') {
+                indent++;
+            }
+            else if (line[i] === '\t') {
+                throw new LexerError('Tab characters are not allowed for indentation, use spaces', this.lineIndex + 1, i + 1);
+            }
+            else {
+                break;
+            }
+        }
+        return indent;
+    }
+    emitIndentation(indent) {
+        const current = this.indentStack[this.indentStack.length - 1];
+        if (indent > current) {
+            this.indentStack.push(indent);
+            this.emit('INDENT', '');
+        }
+        else if (indent < current) {
+            while (this.indentStack[this.indentStack.length - 1] > indent) {
+                this.indentStack.pop();
+                this.emit('DEDENT', '');
+            }
+            if (this.indentStack[this.indentStack.length - 1] !== indent) {
+                throw new LexerError('Inconsistent indentation', this.lineIndex + 1, indent + 1);
+            }
+        }
+    }
+    processLine() {
+        const line = this.currentLine;
+        // Comment: //-
+        if (line.startsWith('//-')) {
+            this.scanComment();
+            return;
+        }
+        // Pass-through comment: //
+        if (line.startsWith('//')) {
+            this.scanPassthroughComment();
+            return;
+        }
+        // else if (must check before 'else' alone)
+        if (line === 'else if' || line.startsWith('else if ') || line.startsWith('else if(')) {
+            this.scanElseIf();
+            return;
+        }
+        // else
+        if (line === 'else') {
+            this.emit('ELSE', 'else');
+            this.pos = 4;
+            return;
+        }
+        // Check single-word keywords with word boundary
+        for (const keyword of KEYWORDS) {
+            if (this.matchesKeyword(line, keyword)) {
+                this.dispatchKeyword(keyword);
+                return;
+            }
+        }
+        // Mixin call: +name(...)
+        if (line.startsWith('+')) {
+            this.scanMixinCall();
+            return;
+        }
+        // Pipe text: | content
+        if (line.startsWith('|')) {
+            this.scanPipe();
+            return;
+        }
+        // Element: starts with tag, .class, or #id
+        this.scanElement();
+    }
+    matchesKeyword(line, keyword) {
+        if (!line.startsWith(keyword))
+            return false;
+        if (line.length === keyword.length)
+            return true;
+        const next = line[keyword.length];
+        return next === ' ' || next === '(';
+    }
+    dispatchKeyword(keyword) {
+        switch (keyword) {
+            case 'import':
+                this.scanImport();
+                break;
+            case 'template':
+                this.scanTemplate();
+                break;
+            case 'mixin':
+                this.scanMixin();
+                break;
+            case 'extends':
+                this.scanExtends();
+                break;
+            case 'block':
+                this.scanBlock();
+                break;
+            case 'include':
+                this.scanInclude();
+                break;
+            case 'doctype':
+                this.scanDoctype();
+                break;
+            case 'if':
+                this.scanIf();
+                break;
+            case 'for':
+                this.scanFor();
+                break;
+        }
+    }
+    // --- Simple scanners ---
+    scanComment() {
+        // //- or //- text
+        const text = this.currentLine.length > 3 ? this.currentLine.slice(3).trimStart() : '';
+        this.emit('COMMENT', text);
+        this.pos = this.currentLine.length;
+    }
+    scanPassthroughComment() {
+        // // or // text — capture everything after //
+        const text = this.currentLine.slice(2);
+        this.emit('PASSTHROUGH_COMMENT', text);
+        this.pos = this.currentLine.length;
+    }
+    scanImport() {
+        this.emit('IMPORT', this.currentLine);
+        this.pos = this.currentLine.length;
+    }
+    scanDoctype() {
+        const variant = this.currentLine.slice('doctype '.length);
+        this.emit('DOCTYPE', variant);
+        this.pos = this.currentLine.length;
+    }
+    scanBlock() {
+        this.emit('BLOCK', 'block');
+        const name = this.currentLine.slice('block '.length).trim();
+        this.emit('IDENTIFIER', name);
+        this.pos = this.currentLine.length;
+    }
+    scanInclude() {
+        this.emit('INCLUDE', 'include');
+        const path = this.currentLine.slice('include '.length).trim();
+        this.emit('PATH', path);
+        this.pos = this.currentLine.length;
+    }
+    // --- Declaration scanners ---
+    scanTemplate() {
+        this.pos = 'template '.length;
+        this.emit('TEMPLATE', 'template');
+        const name = this.scanIdentifier();
+        this.emit('IDENTIFIER', name);
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            const params = this.scanBalancedParens();
+            this.emit('PARAMS', params);
+        }
+    }
+    scanMixin() {
+        this.pos = 'mixin '.length;
+        this.emit('MIXIN', 'mixin');
+        const name = this.scanIdentifier();
+        this.emit('IDENTIFIER', name);
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            const params = this.scanBalancedParens();
+            this.emit('PARAMS', params);
+        }
+    }
+    scanExtends() {
+        this.pos = 'extends '.length;
+        this.emit('EXTENDS', 'extends');
+        const name = this.scanIdentifier();
+        this.emit('IDENTIFIER', name);
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            const params = this.scanBalancedParens();
+            this.emit('PARAMS', params);
+        }
+    }
+    // --- Control flow scanners ---
+    scanIf() {
+        this.pos = 'if '.length;
+        this.emit('IF', 'if');
+        const expr = this.currentLine.slice(this.pos);
+        this.emit('BUFFERED_CODE', expr);
+        this.pos = this.currentLine.length;
+    }
+    scanElseIf() {
+        this.pos = 'else if '.length;
+        this.emit('ELSE_IF', 'else if');
+        const expr = this.currentLine.slice(this.pos);
+        this.emit('BUFFERED_CODE', expr);
+        this.pos = this.currentLine.length;
+    }
+    scanFor() {
+        this.pos = 'for '.length;
+        this.emit('FOR', 'for');
+        this.skipSpaces();
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            const params = this.scanBalancedParens();
+            this.emit('PARAMS', params);
+        }
+    }
+    // --- Element scanner ---
+    scanElement() {
+        const ch = this.currentLine[this.pos];
+        // Tag name or implicit div
+        if (ch === '.' || ch === '#') {
+            this.emit('TAG', 'div');
+        }
+        else {
+            const tag = this.scanTagName();
+            this.emit('TAG', tag);
+        }
+        // Classes and IDs
+        this.scanClassesAndIds();
+        // Attributes
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            this.emit('ATTR_START', '(');
+            this.pos++; // skip '('
+            this.scanAttributes();
+            this.emit('ATTR_END', ')');
+        }
+        // Trailing content
+        this.scanTrailingContent();
+    }
+    scanTagName() {
+        const start = this.pos;
+        while (this.pos < this.currentLine.length) {
+            const ch = this.currentLine[this.pos];
+            if (/[a-zA-Z0-9-]/.test(ch)) {
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+        return this.currentLine.slice(start, this.pos);
+    }
+    scanClassesAndIds() {
+        while (this.pos < this.currentLine.length) {
+            const ch = this.currentLine[this.pos];
+            if (ch === '.') {
+                this.pos++; // skip dot
+                const start = this.pos;
+                while (this.pos < this.currentLine.length) {
+                    const c = this.currentLine[this.pos];
+                    if (c === ' ' || c === '(' || c === '#' || c === '.' || c === '=')
+                        break;
+                    this.pos++;
+                }
+                this.emit('CLASS', this.currentLine.slice(start, this.pos));
+            }
+            else if (ch === '#') {
+                this.pos++; // skip hash
+                const start = this.pos;
+                while (this.pos < this.currentLine.length) {
+                    const c = this.currentLine[this.pos];
+                    if (c === ' ' || c === '(' || c === '#' || c === '.' || c === '=')
+                        break;
+                    this.pos++;
+                }
+                this.emit('ID', this.currentLine.slice(start, this.pos));
+            }
+            else {
+                break;
+            }
+        }
+    }
+    scanAttributes() {
+        while (this.pos < this.currentLine.length) {
+            this.skipSpaces();
+            if (this.pos >= this.currentLine.length)
+                break;
+            if (this.currentLine[this.pos] === ')') {
+                this.pos++; // skip closing paren
+                return;
+            }
+            // Spread: ...identifier
+            if (this.currentLine[this.pos] === '.' &&
+                this.pos + 2 < this.currentLine.length &&
+                this.currentLine[this.pos + 1] === '.' &&
+                this.currentLine[this.pos + 2] === '.') {
+                this.pos += 3; // skip ...
+                const name = this.scanIdentifier();
+                this.emit('SPREAD', name);
+                continue;
+            }
+            // Attribute name
+            const name = this.scanAttrName();
+            this.emit('ATTR_NAME', name);
+            // Check for = value
+            if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '=') {
+                this.pos++; // skip =
+                const value = this.scanAttrValue();
+                this.emit('ATTR_VALUE', value);
+            }
+        }
+    }
+    scanAttrName() {
+        const start = this.pos;
+        while (this.pos < this.currentLine.length) {
+            const ch = this.currentLine[this.pos];
+            if (/[a-zA-Z0-9_-]/.test(ch)) {
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+        return this.currentLine.slice(start, this.pos);
+    }
+    scanAttrValue() {
+        const ch = this.currentLine[this.pos];
+        // Quoted string
+        if (ch === '"' || ch === "'") {
+            return this.scanString(ch);
+        }
+        // Template literal
+        if (ch === '`') {
+            return this.scanTemplateLiteral();
+        }
+        // Bare expression — scan until whitespace, ), or end
+        const start = this.pos;
+        let depth = 0;
+        while (this.pos < this.currentLine.length) {
+            const c = this.currentLine[this.pos];
+            if (c === '(') {
+                depth++;
+                this.pos++;
+            }
+            else if (c === ')') {
+                if (depth === 0)
+                    break;
+                depth--;
+                this.pos++;
+            }
+            else if (c === ' ' && depth === 0) {
+                break;
+            }
+            else {
+                this.pos++;
+            }
+        }
+        return this.currentLine.slice(start, this.pos);
+    }
+    scanTrailingContent() {
+        if (this.pos >= this.currentLine.length)
+            return;
+        const ch = this.currentLine[this.pos];
+        // Buffered code: = expression
+        if (ch === '=') {
+            this.pos++; // skip =
+            if (this.pos < this.currentLine.length && this.currentLine[this.pos] === ' ') {
+                this.pos++; // skip space after =
+            }
+            const rest = this.currentLine.slice(this.pos);
+            if (rest.includes('#{')) {
+                this.scanTextWithInterpolation(rest);
+            }
+            else {
+                this.emit('BUFFERED_CODE', rest);
+            }
+            this.pos = this.currentLine.length;
+            return;
+        }
+        // Inline text: space then text
+        if (ch === ' ') {
+            this.pos++; // skip leading space
+            const rest = this.currentLine.slice(this.pos);
+            this.scanTextWithInterpolation(rest);
+            this.pos = this.currentLine.length;
+            return;
+        }
+    }
+    // --- Mixin call scanner ---
+    scanMixinCall() {
+        this.pos = 1; // skip +
+        const name = this.scanIdentifier();
+        this.emit('MIXIN_CALL', name);
+        // Args in first set of parens
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            const args = this.scanBalancedParens();
+            this.emit('PARAMS', args);
+        }
+        // Extra attrs in second set of parens
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
+            this.emit('ATTR_START', '(');
+            this.pos++; // skip '('
+            this.scanAttributes();
+            this.emit('ATTR_END', ')');
+        }
+    }
+    // --- Pipe scanner ---
+    scanPipe() {
+        this.emit('PIPE', '|');
+        this.pos = 1; // skip |
+        if (this.pos < this.currentLine.length && this.currentLine[this.pos] === ' ') {
+            this.pos++; // skip space after |
+        }
+        const rest = this.currentLine.slice(this.pos);
+        if (rest.length > 0) {
+            this.scanTextWithInterpolation(rest);
+        }
+        this.pos = this.currentLine.length;
+    }
+    // --- Text with interpolation ---
+    scanTextWithInterpolation(text) {
+        let i = 0;
+        let buf = '';
+        while (i < text.length) {
+            // Check for interpolation #{...}
+            if (text[i] === '#' && i + 1 < text.length && text[i + 1] === '{') {
+                // Emit accumulated text
+                if (buf.length > 0) {
+                    this.emit('TEXT', buf);
+                    buf = '';
+                }
+                i += 2; // skip #{
+                // Scan balanced braces to find closing }
+                let depth = 1;
+                const start = i;
+                while (i < text.length && depth > 0) {
+                    const ch = text[i];
+                    if (ch === '{') {
+                        depth++;
+                    }
+                    else if (ch === '}') {
+                        depth--;
+                        if (depth === 0)
+                            break;
+                    }
+                    else if (ch === '"' || ch === "'" || ch === '`') {
+                        // Skip string contents
+                        const quote = ch;
+                        i++;
+                        while (i < text.length) {
+                            if (text[i] === '\\') {
+                                i++; // skip escaped char
+                            }
+                            else if (text[i] === quote) {
+                                break;
+                            }
+                            i++;
+                        }
+                    }
+                    i++;
+                }
+                if (depth !== 0) {
+                    throw new LexerError('Unterminated interpolation', this.lineIndex + 1, this.indentWidth + this.pos + 1);
+                }
+                this.emit('INTERPOLATION', text.slice(start, i));
+                i++; // skip closing }
+            }
+            else {
+                buf += text[i];
+                i++;
+            }
+        }
+        // Emit remaining text
+        if (buf.length > 0) {
+            this.emit('TEXT', buf);
+        }
+    }
+    // --- Balanced scanning helpers ---
+    scanBalancedParens() {
+        if (this.currentLine[this.pos] !== '(') {
+            throw new LexerError('Expected opening parenthesis', this.lineIndex + 1, this.indentWidth + this.pos + 1);
+        }
+        this.pos++; // skip opening (
+        let depth = 1;
+        const start = this.pos;
+        while (this.pos < this.currentLine.length && depth > 0) {
+            const ch = this.currentLine[this.pos];
+            if (ch === '(') {
+                depth++;
+                this.pos++;
+            }
+            else if (ch === ')') {
+                depth--;
+                if (depth === 0)
+                    break;
+                this.pos++;
+            }
+            else if (ch === '"' || ch === "'" || ch === '`') {
+                this.skipStringInPlace(ch);
+            }
+            else {
+                this.pos++;
+            }
+        }
+        if (depth !== 0) {
+            throw new LexerError('Unterminated parentheses', this.lineIndex + 1, this.indentWidth + this.pos + 1);
+        }
+        const content = this.currentLine.slice(start, this.pos);
+        this.pos++; // skip closing )
+        return content.trim();
+    }
+    scanString(quote) {
+        const start = this.pos;
+        this.pos++; // skip opening quote
+        while (this.pos < this.currentLine.length) {
+            if (this.currentLine[this.pos] === '\\') {
+                this.pos += 2; // skip escaped char
+            }
+            else if (this.currentLine[this.pos] === quote) {
+                this.pos++; // skip closing quote
+                return this.currentLine.slice(start, this.pos);
+            }
+            else {
+                this.pos++;
+            }
+        }
+        throw new LexerError('Unterminated string', this.lineIndex + 1, this.indentWidth + this.pos + 1);
+    }
+    scanTemplateLiteral() {
+        const start = this.pos;
+        this.pos++; // skip opening backtick
+        while (this.pos < this.currentLine.length) {
+            if (this.currentLine[this.pos] === '\\') {
+                this.pos += 2;
+            }
+            else if (this.currentLine[this.pos] === '`') {
+                this.pos++;
+                return this.currentLine.slice(start, this.pos);
+            }
+            else if (this.currentLine[this.pos] === '$' &&
+                this.pos + 1 < this.currentLine.length &&
+                this.currentLine[this.pos + 1] === '{') {
+                this.pos += 2; // skip ${
+                let depth = 1;
+                while (this.pos < this.currentLine.length && depth > 0) {
+                    if (this.currentLine[this.pos] === '{') {
+                        depth++;
+                    }
+                    else if (this.currentLine[this.pos] === '}') {
+                        depth--;
+                    }
+                    else if (this.currentLine[this.pos] === '"' ||
+                        this.currentLine[this.pos] === "'" ||
+                        this.currentLine[this.pos] === '`') {
+                        this.skipStringInPlace(this.currentLine[this.pos]);
+                        continue;
+                    }
+                    this.pos++;
+                }
+            }
+            else {
+                this.pos++;
+            }
+        }
+        throw new LexerError('Unterminated template literal', this.lineIndex + 1, this.indentWidth + this.pos + 1);
+    }
+    /** Skip over a string in-place (used within balanced paren scanning) */
+    skipStringInPlace(quote) {
+        this.pos++; // skip opening quote
+        while (this.pos < this.currentLine.length) {
+            if (this.currentLine[this.pos] === '\\') {
+                this.pos += 2;
+            }
+            else if (this.currentLine[this.pos] === quote) {
+                this.pos++;
+                return;
+            }
+            else if (quote === '`' &&
+                this.currentLine[this.pos] === '$' &&
+                this.pos + 1 < this.currentLine.length &&
+                this.currentLine[this.pos + 1] === '{') {
+                // Template literal ${...} - skip the nested expression
+                this.pos += 2;
+                let depth = 1;
+                while (this.pos < this.currentLine.length && depth > 0) {
+                    if (this.currentLine[this.pos] === '{')
+                        depth++;
+                    else if (this.currentLine[this.pos] === '}')
+                        depth--;
+                    if (depth > 0)
+                        this.pos++;
+                }
+                if (this.pos < this.currentLine.length)
+                    this.pos++; // skip closing }
+                return;
+            }
+            else {
+                this.pos++;
+            }
+        }
+    }
+    // --- Utility methods ---
+    scanIdentifier() {
+        const start = this.pos;
+        while (this.pos < this.currentLine.length) {
+            const ch = this.currentLine[this.pos];
+            if (/[a-zA-Z0-9_]/.test(ch)) {
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+        return this.currentLine.slice(start, this.pos);
+    }
+    skipSpaces() {
+        while (this.pos < this.currentLine.length && this.currentLine[this.pos] === ' ') {
+            this.pos++;
+        }
+    }
+    emit(type, value) {
+        this.tokens.push({
+            type,
+            value,
+            line: this.lineIndex + 1,
+            col: this.indentWidth + this.pos + 1,
+        });
+    }
+}
+export function lex(source) {
+    return new Lexer(source).lex();
+}
+//# sourceMappingURL=index.js.map