@fc-components/monaco-editor 0.1.27 → 0.3.1

package/src/expr/parser/parser.ts

@@ -0,0 +1,581 @@
+/**
+ * Expr-lang recursive descent parser
+ * Ported from Go's expr-lang parser with precedence climbing algorithm
+ */
+
+import { Lexer } from './lexer';
+import { Token, TokenKind, ParseError, EOF_TOKEN, OPERATOR_PRECEDENCE, UNARY_OPERATORS, COMPARISON_OPERATORS } from './types';
+
+export class ExprParser {
+  private lexer: Lexer;
+  private current: Token = { ...EOF_TOKEN };
+  private errors: ParseError[] = [];
+
+  constructor() {
+    this.lexer = new Lexer();
+  }
+
+  /**
+   * Parse an expr-lang expression and return any syntax errors.
+   * Returns empty array if the expression is valid.
+   */
+  parse(input: string): ParseError[] {
+    this.errors = [];
+    this.lexer.reset(input);
+    this.advance();
+
+    if (input.trim().length === 0) {
+      return [];
+    }
+
+    this.parseSequenceExpression();
+
+    // Check for unexpected tokens at the end
+    if (this.curKind() !== TokenKind.EOF && this.errors.length === 0) {
+      this.error(`unexpected token "${this.curVal()}"`);
+    }
+
+    return this.errors;
+  }
+
+  private advance(): void {
+    this.current = this.lexer.next();
+  }
+
+  private curKind(): TokenKind {
+    return this.current.kind;
+  }
+
+  private curVal(): string {
+    return this.current.value;
+  }
+
+  private expect(kind: TokenKind, value?: string): boolean {
+    if (this.curKind() === kind && (value === undefined || this.curVal() === value)) {
+      this.advance();
+      return true;
+    }
+    if (value) {
+      this.error(`expected "${value}" but got "${this.curVal()}"`);
+    } else {
+      this.error(`unexpected token "${this.curVal()}"`);
+    }
+    return false;
+  }
+
+  private error(message: string): void {
+    if (this.errors.length === 0) {
+      // Calculate end position — approximate
+      const endLine = this.current.line;
+      const endColumn = this.current.column + this.curVal().length;
+
+      this.errors.push({
+        message,
+        startLine: this.current.line,
+        startColumn: this.current.column,
+        endLine,
+        endColumn,
+      });
+    }
+  }
+
+  private errorAt(token: Token, message: string): void {
+    if (this.errors.length === 0) {
+      const endColumn = token.column + token.value.length;
+      this.errors.push({
+        message,
+        startLine: token.line,
+        startColumn: token.column,
+        endLine: token.line,
+        endColumn,
+      });
+    }
+  }
+
+  // ========== Parsing Functions ==========
+
+  /**
+   * parseSequenceExpression parses multiple expressions separated by semicolons.
+   */
+  private parseSequenceExpression(): void {
+    if (this.errors.length > 0) return;
+    this.parseExpression(0);
+
+    while (this.curVal() === ';' && this.errors.length === 0) {
+      this.advance();
+      if (this.curKind() === TokenKind.EOF) break;
+      this.parseExpression(0);
+    }
+  }
+
+  /**
+   * parseExpression uses precedence climbing to parse binary expressions.
+   */
+  private parseExpression(precedence: number): void {
+    if (this.errors.length > 0) return;
+
+    // Handle "let" at precedence 0
+    if (precedence === 0 && this.curVal() === 'let') {
+      this.parseVariableDeclaration();
+      return;
+    }
+
+    // Handle "if" at precedence 0
+    if (precedence === 0 && this.curVal() === 'if') {
+      this.parseConditionalIf();
+      return;
+    }
+
+    // Handle unary operators
+    if (UNARY_OPERATORS.has(this.curVal()) && this.curKind() === TokenKind.Operator) {
+      const unaryToken = this.current;
+      this.advance();
+      if (this.curKind() === TokenKind.EOF) {
+        this.errorAt(unaryToken, 'unexpected token EOF');
+        return;
+      }
+      if (this.errors.length > 0) return;
+      this.parsePrimary();
+      if (this.errors.length > 0) return;
+      this.parsePostfixExpression();
+      return;
+    }
+
+    this.parsePrimary();
+    if (this.errors.length > 0) return;
+    this.parsePostfixExpression();
+    if (this.errors.length > 0) return;
+
+    // Handle binary operators with precedence climbing
+    while (this.curKind() === TokenKind.Operator && this.errors.length === 0) {
+      const op = this.curVal();
+      const opToken = this.current;
+
+      // Handle pipe operator |
+      if (op === '|') {
+        this.advance(); // skip |
+        if (this.curKind() === TokenKind.EOF) {
+          this.errorAt(opToken, 'unexpected token EOF');
+          return;
+        }
+        if (this.curKind() === TokenKind.Identifier) {
+          this.advance(); // skip identifier
+          this.parseArguments();
+          if (this.curVal() === ';') break;
+          continue;
+        }
+        this.error(`expected identifier after pipe "|" but got "${this.curVal()}"`);
+        return;
+      }
+
+      // Handle semicolon — end of this expression
+      if (op === ';') break;
+
+      // Check precedence
+      const opPrec = OPERATOR_PRECEDENCE[op];
+      if (opPrec === undefined || opPrec < precedence) break;
+
+      // Handle "not" prefix for "not in", "not contains", etc.
+      if (op === 'not') {
+        this.advance();
+        const nextOp = this.curVal();
+        const negatedPrec = OPERATOR_PRECEDENCE[nextOp];
+        if (negatedPrec !== undefined && negatedPrec >= precedence) {
+          this.advance();
+          this.parseExpression(negatedPrec + 1);
+          continue;
+        }
+        this.error(`unexpected token "${nextOp}" after "not"`);
+        return;
+      }
+
+      // Handle chained comparisons: a < b < c => (a < b) && (b < c)
+      if (COMPARISON_OPERATORS.has(op)) {
+        this.advance();
+        if (this.curKind() === TokenKind.EOF) {
+          this.errorAt(opToken, 'unexpected token EOF');
+          return;
+        }
+        this.parseExpression(opPrec + 1);
+        // Keep parsing chained comparisons
+        while (this.curKind() === TokenKind.Operator && COMPARISON_OPERATORS.has(this.curVal()) && this.errors.length === 0) {
+          const chainOpToken = this.current;
+          this.advance();
+          if (this.curKind() === TokenKind.EOF) {
+            this.errorAt(chainOpToken, 'unexpected token EOF');
+            return;
+          }
+          this.parseExpression((OPERATOR_PRECEDENCE[this.curVal()] || 0) + 1);
+        }
+        continue;
+      }
+
+      this.advance();
+
+      if (this.curKind() === TokenKind.EOF) {
+        this.errorAt(opToken, 'unexpected token EOF');
+        return;
+      }
+
+      // Right-associative operators bind to the right
+      // For simplicity, parse with same precedence for right-assoc
+      this.parseExpression(opPrec + 1);
+
+      // Handle ternary ? :
+      if (precedence === 0 && this.curVal() === '?') {
+        this.parseConditional();
+      }
+    }
+
+    // Handle ternary ? : at precedence 0
+    if (precedence === 0 && this.curVal() === '?') {
+      this.parseConditional();
+    }
+  }
+
+  /**
+   * parsePrimary handles unary operators, parentheses, and the #/. pointer prefix.
+   */
+  private parsePrimary(): void {
+    if (this.errors.length > 0) return;
+
+    // Unary operators are handled in parseExpression
+
+    // Parenthesized expression
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+      this.advance(); // skip (
+      this.parseSequenceExpression();
+      if (!this.expect(TokenKind.Bracket, ')')) {
+        return;
+      }
+      return;
+    }
+
+    // Handle # or . prefix (in predicates)
+    if ((this.curVal() === '#' || this.curVal() === '.') && this.curKind() === TokenKind.Operator) {
+      this.advance();
+      if (this.curKind() === TokenKind.Identifier) {
+        this.advance();
+      }
+      this.parsePostfixExpression();
+      return;
+    }
+
+    this.parseSecondary();
+  }
+
+  /**
+   * parseSecondary handles identifiers, literals, arrays, and maps.
+   */
+  private parseSecondary(): void {
+    if (this.errors.length > 0) return;
+
+    const token = this.current;
+
+    switch (token.kind) {
+      case TokenKind.Identifier: {
+        this.advance();
+        // Check for function call
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+          this.parseArguments();
+        }
+        break;
+      }
+
+      case TokenKind.Number: {
+        this.advance();
+        break;
+      }
+
+      case TokenKind.String: {
+        this.advance();
+        break;
+      }
+
+      case TokenKind.Bracket: {
+        if (token.value === '[') {
+          this.parseArrayExpression();
+        } else if (token.value === '{') {
+          this.parseMapExpression();
+        } else {
+          this.error(`unexpected token "${token.value}"`);
+        }
+        break;
+      }
+
+      default:
+        this.error(`unexpected token "${token.value}"`);
+        break;
+    }
+  }
+
+  /**
+   * parsePostfixExpression handles .member, ?.member, [index], [from:to], and calls after the primary.
+   */
+  private parsePostfixExpression(): void {
+    while (this.errors.length === 0) {
+      const token = this.current;
+
+      // .member or ?.member
+      if (token.kind === TokenKind.Operator && (token.value === '.' || token.value === '?.')) {
+        this.advance();
+        // After . or ?., expect an identifier (or operator like "not" that can be a method name)
+        if (this.curKind() === TokenKind.Identifier || this.curKind() === TokenKind.Operator) {
+          this.advance();
+          // Check for method call: obj.method()
+          if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+            this.parseArguments();
+          }
+        } else if (this.curKind() === TokenKind.Bracket && this.curVal() === '[' && token.value === '?.') {
+          // obj?[index] — handle bracket after ?.
+          this.advance();
+          this.parseExpression(0);
+          this.expect(TokenKind.Bracket, ']');
+        } else {
+          this.error(`expected property name after "${token.value}" but got "${this.curVal()}"`);
+          return;
+        }
+        continue;
+      }
+
+      // [index] or [from:to]
+      if (token.kind === TokenKind.Bracket && token.value === '[') {
+        this.advance();
+
+        // Check for slice: [:] or [:to]
+        if (this.curKind() === TokenKind.Operator && this.curVal() === ':') {
+          this.advance();
+          if (this.curKind() !== TokenKind.Bracket || this.curVal() !== ']') {
+            this.parseExpression(0);
+          }
+          this.expect(TokenKind.Bracket, ']');
+        } else {
+          // Index expression
+          this.parseExpression(0);
+
+          // Check for slice: [from:]
+          if (this.curKind() === TokenKind.Operator && this.curVal() === ':') {
+            this.advance();
+            if (this.curKind() !== TokenKind.Bracket || this.curVal() !== ']') {
+              this.parseExpression(0);
+            }
+          }
+          this.expect(TokenKind.Bracket, ']');
+        }
+        continue;
+      }
+
+      // Function call after member access
+      if (token.kind === TokenKind.Bracket && token.value === '(') {
+        this.parseArguments();
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  /**
+   * parseVariableDeclaration parses "let name = value; rest"
+   */
+  private parseVariableDeclaration(): void {
+    this.expect(TokenKind.Operator, 'let');
+    if (this.errors.length > 0) return;
+
+    if (this.curKind() !== TokenKind.Identifier) {
+      this.error(`expected variable name after "let" but got "${this.curVal()}"`);
+      return;
+    }
+    this.advance(); // skip variable name
+
+    if (!this.expect(TokenKind.Operator, '=')) return;
+
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+
+    // Optional semicolon after value
+    if (this.curVal() === ';') {
+      this.advance();
+      if (this.curKind() !== TokenKind.EOF) {
+        this.parseSequenceExpression();
+      }
+    }
+  }
+
+  /**
+   * parseConditionalIf parses "if expr { expr1 } else { expr2 }" or "if expr { expr1 } else if ..."
+   */
+  private parseConditionalIf(): void {
+    this.advance(); // skip 'if'
+    if (this.errors.length > 0) return;
+
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+
+    if (!this.expect(TokenKind.Bracket, '{')) return;
+
+    this.parseSequenceExpression();
+    if (this.errors.length > 0) return;
+
+    if (!this.expect(TokenKind.Bracket, '}')) return;
+
+    if (!this.expect(TokenKind.Operator, 'else')) return;
+
+    // Nested if
+    if (this.curVal() === 'if') {
+      this.parseConditionalIf();
+      return;
+    }
+
+    if (!this.expect(TokenKind.Bracket, '{')) return;
+    this.parseSequenceExpression();
+    if (this.errors.length > 0) return;
+    this.expect(TokenKind.Bracket, '}');
+  }
+
+  /**
+   * parseConditional parses "expr ? expr1 : expr2" or "expr ?: expr2"
+   */
+  private parseConditional(): void {
+    if (this.curVal() !== '?') return;
+    this.advance(); // skip ?
+
+    // Elvis operator ?:
+    if (this.curVal() === ':') {
+      this.advance();
+      this.parseExpression(0);
+      return;
+    }
+
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+
+    if (!this.expect(TokenKind.Operator, ':')) return;
+    this.parseExpression(0);
+  }
+
+  /**
+   * parseArguments parses function call arguments: (arg1, arg2, ...)
+   */
+  private parseArguments(): void {
+    if (!this.expect(TokenKind.Bracket, '(')) return;
+
+    while (this.curKind() !== TokenKind.Bracket || this.curVal() !== ')') {
+      if (this.curKind() === TokenKind.EOF) {
+        this.error('unexpected end of expression, expected ")"');
+        return;
+      }
+
+      if (this.curVal() === ',') {
+        this.advance();
+        continue;
+      }
+
+      // Check for predicate { ... } argument
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === '{') {
+        this.advance();
+        this.parseSequenceExpression();
+        this.expect(TokenKind.Bracket, '}');
+      } else {
+        this.parseExpression(0);
+      }
+
+      if (this.errors.length > 0) return;
+
+      if (this.curVal() === ',') {
+        this.advance();
+        // Allow trailing comma
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === ')') {
+          break;
+        }
+      }
+    }
+
+    this.expect(TokenKind.Bracket, ')');
+  }
+
+  /**
+   * parseArrayExpression parses "[elem1, elem2, ...]"
+   */
+  private parseArrayExpression(): void {
+    this.expect(TokenKind.Bracket, '[');
+    if (this.errors.length > 0) return;
+
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+      this.advance();
+      return;
+    }
+
+    while (this.errors.length === 0) {
+      this.parseExpression(0);
+      if (this.errors.length > 0) return;
+
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+        break;
+      }
+
+      if (this.curVal() === ',') {
+        this.advance();
+        // Allow trailing comma
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+          break;
+        }
+        continue;
+      }
+
+      this.error(`expected "," or "]" but got "${this.curVal()}"`);
+      return;
+    }
+
+    this.expect(TokenKind.Bracket, ']');
+  }
+
+  /**
+   * parseMapExpression parses "{key: value, ...}"
+   */
+  private parseMapExpression(): void {
+    this.expect(TokenKind.Bracket, '{');
+    if (this.errors.length > 0) return;
+
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+      this.advance();
+      return;
+    }
+
+    while (this.errors.length === 0) {
+      // Key: identifier, string, number, or parenthesized expression
+      if (this.curKind() === TokenKind.Identifier || this.curKind() === TokenKind.String || this.curKind() === TokenKind.Number) {
+        this.advance();
+      } else if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+        this.advance();
+        this.parseExpression(0);
+        this.expect(TokenKind.Bracket, ')');
+      } else {
+        this.error(`map key must be a string, number, identifier, or parenthesized expression, got "${this.curVal()}"`);
+        return;
+      }
+
+      if (!this.expect(TokenKind.Operator, ':')) return;
+
+      this.parseExpression(0);
+      if (this.errors.length > 0) return;
+
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+        break;
+      }
+
+      if (this.curVal() === ',') {
+        this.advance();
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+          break;
+        }
+        continue;
+      }
+
+      this.error(`expected "," or "}" but got "${this.curVal()}"`);
+      return;
+    }
+
+    this.expect(TokenKind.Bracket, '}');
+  }
+}

package/src/expr/parser/types.ts

@@ -0,0 +1,77 @@
+/**
+ * Expr-lang token types and AST definitions
+ */
+
+export enum TokenKind {
+  Identifier = 'Identifier',
+  Number = 'Number',
+  String = 'String',
+  Operator = 'Operator',
+  Bracket = 'Bracket',
+  EOF = 'EOF',
+}
+
+export interface Token {
+  kind: TokenKind;
+  value: string;
+  start: number;
+  end: number;
+  line: number;
+  column: number;
+}
+
+export interface ParseError {
+  message: string;
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}
+
+export const EOF_TOKEN: Token = {
+  kind: TokenKind.EOF,
+  value: '',
+  start: 0,
+  end: 0,
+  line: 0,
+  column: 0,
+};
+
+// Operator precedence (higher = binds tighter)
+export const OPERATOR_PRECEDENCE: Record<string, number> = {
+  '??': 1,
+  '||': 2,
+  or: 2,
+  '&&': 3,
+  and: 3,
+  '==': 4,
+  '!=': 4,
+  '<': 5,
+  '>': 5,
+  '<=': 5,
+  '>=': 5,
+  in: 5,
+  matches: 5,
+  contains: 5,
+  startsWith: 5,
+  endsWith: 5,
+  '+': 6,
+  '-': 6,
+  '*': 7,
+  '/': 7,
+  '%': 7,
+  '^': 8,
+  '**': 8,
+};
+
+// Unary operators
+export const UNARY_OPERATORS = new Set(['!', 'not', '-']);
+
+// Right-associative operators
+export const RIGHT_ASSOCIATIVE = new Set(['**', '^']);
+
+// Comparison operators (for chained comparisons)
+export const COMPARISON_OPERATORS = new Set(['<', '>', '<=', '>=', '==', '!=']);
+
+// Keywords
+export const KEYWORDS = new Set(['let', 'true', 'false', 'nil', 'in', 'not', 'and', 'or', 'if', 'else']);

package/src/expr/types.ts

@@ -0,0 +1,17 @@
+export interface ExprEditorProps {
+  className?: string;
+  maxHeight?: number | string;
+  fontSize?: number;
+  size?: 'small' | 'middle' | 'large';
+  theme?: 'light' | 'dark';
+  value?: string;
+  placeholder?: string;
+  enableAutocomplete?: boolean;
+  readOnly?: boolean;
+  disabled?: boolean;
+  onChange?: (value: string) => void;
+  onEnter?: (value: string) => void;
+  onBlur?: (value: string) => void;
+  onFocus?: (value: string) => void;
+  editorDidMount?: (editor: any) => void;
+}