Building Recursive Descent Parsers for JSON

enum TokenType {
  BraceOpen, BraceClose, BracketOpen, BracketClose, Colon, Comma,
  String, Number, True, False, Null, EOF
}

interface Token {
  type: TokenType;
  value?: string | number | boolean | null;
}

class Tokenizer {
  private input: string;
  private position: number = 0;
  // ... tokenizer implementation ...
  // next(): Token - returns the next token
  // peek(): Token - returns the next token without consuming it
}

class Parser {
  private tokenizer: Tokenizer;
  private currentToken: Token;

  constructor(tokenizer: Tokenizer) {
    this.tokenizer = tokenizer;
    this.currentToken = this.tokenizer.next(); // Get the first token
  }

  // Helper to consume the current token and advance
  private eat(type: TokenType): void {
    if (this.currentToken.type === type) {
      this.currentToken = this.tokenizer.next();
    } else {
      throw new Error(`Unexpected token: Expected ${TokenType[type]} but got ${TokenType[this.currentToken.type]}`);
    }
  }

  // Entry point: Parse a JSON Value (which is the root)
  parse(): any {
    const value = this.parseValue();
    if (this.currentToken.type !== TokenType.EOF) {
        throw new Error("Unexpected data after parsing root value.");
    }
    return value;
  }

  // Parses any valid JSON value
  private parseValue(): any {
    switch (this.currentToken.type) {
      case TokenType.BraceOpen:
        return this.parseObject();
      case TokenType.BracketOpen:
        return this.parseArray();
      case TokenType.String:
        return this.parseString();
      case TokenType.Number:
        return this.parseNumber();
      case TokenType.True:
        return this.parseBoolean();
      case TokenType.False:
        return this.parseBoolean();
      case TokenType.Null:
        return this.parseNull();
      default:
        throw new Error(`Unexpected token type for value: ${TokenType[this.currentToken.type]}`);
    }
  }

  // Parses a JSON object
  private parseObject(): { [key: string]: any } {
    this.eat(TokenType.BraceOpen);
    const obj: { [key: string]: any } = {};

    // Handle empty object
    if (this.currentToken.type === TokenType.BraceClose) {
      this.eat(TokenType.BraceClose);
      return obj;
    }

    // Parse key-value pairs
    while (this.currentToken.type === TokenType.String) {
      const key = this.parseString() as string; // Key must be a string
      this.eat(TokenType.Colon);
      const value = this.parseValue();
      obj[key] = value;

      if (this.currentToken.type === TokenType.Comma) {
        this.eat(TokenType.Comma);
      } else if (this.currentToken.type !== TokenType.BraceClose) {
        throw new Error("Expected comma or closing brace in object.");
      }
    }

    this.eat(TokenType.BraceClose);
    return obj;
  }

  // Parses a JSON array
  private parseArray(): any[] {
    this.eat(TokenType.BracketOpen);
    const arr: any[] = [];

    // Handle empty array
    if (this.currentToken.type === TokenType.BracketClose) {
      this.eat(TokenType.BracketClose);
      return arr;
    }

    // Parse elements
    while (this.currentToken.type !== TokenType.BracketClose) {
      const value = this.parseValue();
      arr.push(value);

      if (this.currentToken.type === TokenType.Comma) {
        this.eat(TokenType.Comma);
      } else if (this.currentToken.type !== TokenType.BracketClose) {
        throw new Error("Expected comma or closing bracket in array.");
      }
    }

    this.eat(TokenType.BracketClose);
    return arr;
  }

  // Parses a JSON string
  private parseString(): string | null {
    if (this.currentToken.type !== TokenType.String) {
      throw new Error("Expected a string token.");
    }
    const value = this.currentToken.value as string;
    this.eat(TokenType.String);
    return value;
  }

  // Parses a JSON number
  private parseNumber(): number | null {
    if (this.currentToken.type !== TokenType.Number) {
      throw new Error("Expected a number token.");
    }
    const value = this.currentToken.value as number;
    this.eat(TokenType.Number);
    return value;
  }

  // Parses JSON true/false
  private parseBoolean(): boolean | null {
    if (this.currentToken.type !== TokenType.True && this.currentToken.type !== TokenType.False) {
      throw new Error("Expected boolean token (true or false).");
    }
    const value = this.currentToken.value as boolean;
    this.eat(this.currentToken.type); // Consume either True or False token
    return value;
  }

  // Parses JSON null
  private parseNull(): null {
    if (this.currentToken.type !== TokenType.Null) {
      throw new Error("Expected null token.");
    }
    this.eat(TokenType.Null);
    return null;
  }
}

// Example Usage (requires Tokenizer implementation):
// const jsonString = '{"name": "Alice", "age": 30, "isStudent": false, "courses": ["Math", "Science"]}';
// const tokenizer = new Tokenizer(jsonString); // Tokenizer needs implementation
// const parser = new Parser(tokenizer);
// try {
//   const parsedData = parser.parse();
//   console.log(parsedData); // Output the parsed JavaScript object/array
// } catch (error) {
//   console.error("Parsing failed:", error.message);
// }