@lowgular/code-graph 0.0.1

package/libs/cli/cypher/src/lib/lexer.js

@@ -0,0 +1,398 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lexer_exports = {};
+__export(lexer_exports, {
+  Lexer: () => Lexer,
+  TokenType: () => TokenType
+});
+module.exports = __toCommonJS(lexer_exports);
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["MATCH"] = "MATCH";
+  TokenType2["OPTIONAL"] = "OPTIONAL";
+  TokenType2["RETURN"] = "RETURN";
+  TokenType2["WHERE"] = "WHERE";
+  TokenType2["AND"] = "AND";
+  TokenType2["OR"] = "OR";
+  TokenType2["AS"] = "AS";
+  TokenType2["IN"] = "IN";
+  TokenType2["NOT"] = "NOT";
+  TokenType2["IS"] = "IS";
+  TokenType2["NULL"] = "NULL";
+  TokenType2["TRUE"] = "TRUE";
+  TokenType2["FALSE"] = "FALSE";
+  TokenType2["STARTS"] = "STARTS";
+  TokenType2["ENDS"] = "ENDS";
+  TokenType2["CONTAINS"] = "CONTAINS";
+  TokenType2["WITH"] = "WITH";
+  TokenType2["LIMIT"] = "LIMIT";
+  TokenType2["ORDER"] = "ORDER";
+  TokenType2["BY"] = "BY";
+  TokenType2["ASC"] = "ASC";
+  TokenType2["DESC"] = "DESC";
+  TokenType2["IDENTIFIER"] = "IDENTIFIER";
+  TokenType2["LABEL"] = "LABEL";
+  TokenType2["LPAREN"] = "LPAREN";
+  TokenType2["RPAREN"] = "RPAREN";
+  TokenType2["LBRACKET"] = "LBRACKET";
+  TokenType2["RBRACKET"] = "RBRACKET";
+  TokenType2["LBRACE"] = "LBRACE";
+  TokenType2["RBRACE"] = "RBRACE";
+  TokenType2["DASH"] = "DASH";
+  TokenType2["ARROW"] = "ARROW";
+  TokenType2["EQUALS"] = "EQUALS";
+  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
+  TokenType2["GT"] = "GT";
+  TokenType2["LT"] = "LT";
+  TokenType2["GTE"] = "GTE";
+  TokenType2["LTE"] = "LTE";
+  TokenType2["COMMA"] = "COMMA";
+  TokenType2["DOT"] = "DOT";
+  TokenType2["PIPE"] = "PIPE";
+  TokenType2["ASTERISK"] = "ASTERISK";
+  TokenType2["REGEX_MATCH"] = "REGEX_MATCH";
+  TokenType2["STRING"] = "STRING";
+  TokenType2["NUMBER"] = "NUMBER";
+  TokenType2["EOF"] = "EOF";
+  return TokenType2;
+})(TokenType || {});
+class Lexer {
+  constructor(input) {
+    this.input = input;
+    this.position = 0;
+    this.currentChar = input.length > 0 ? input[0] : null;
+  }
+  advance() {
+    this.position++;
+    this.currentChar = this.position >= this.input.length ? null : this.input[this.position];
+  }
+  skipWhitespace() {
+    while (this.currentChar && /\s/.test(this.currentChar)) {
+      this.advance();
+    }
+  }
+  readIdentifier() {
+    let result = "";
+    while (this.currentChar && /[a-zA-Z0-9_]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+    return result;
+  }
+  readString() {
+    const quote = this.currentChar;
+    this.advance();
+    let result = "";
+    while (this.currentChar && this.currentChar !== quote) {
+      if (this.currentChar === "\\") {
+        this.advance();
+        if (this.currentChar === "n") {
+          result += "\n";
+        } else if (this.currentChar === "t") {
+          result += "	";
+        } else {
+          result += this.currentChar;
+        }
+        this.advance();
+      } else {
+        result += this.currentChar;
+        this.advance();
+      }
+    }
+    if (this.currentChar === quote) {
+      this.advance();
+    }
+    return result;
+  }
+  readNumber() {
+    let result = "";
+    while (this.currentChar && /[0-9.]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+    return result;
+  }
+  peekKeyword() {
+    const savedPos = this.position;
+    const savedChar = this.currentChar;
+    const keyword = this.readIdentifier();
+    this.position = savedPos;
+    this.currentChar = savedChar;
+    return keyword.length > 0 ? keyword.toUpperCase() : null;
+  }
+  tokenize() {
+    const tokens = [];
+    this.position = 0;
+    this.currentChar = this.input.length > 0 ? this.input[0] : null;
+    while (this.currentChar !== null) {
+      this.skipWhitespace();
+      if (!this.currentChar)
+        break;
+      const startPos = this.position;
+      const keyword = this.peekKeyword();
+      const keywordMap = {
+        MATCH: "MATCH" /* MATCH */,
+        OPTIONAL: "OPTIONAL" /* OPTIONAL */,
+        RETURN: "RETURN" /* RETURN */,
+        WHERE: "WHERE" /* WHERE */,
+        AND: "AND" /* AND */,
+        OR: "OR" /* OR */,
+        AS: "AS" /* AS */,
+        IN: "IN" /* IN */,
+        NOT: "NOT" /* NOT */,
+        IS: "IS" /* IS */,
+        NULL: "NULL" /* NULL */,
+        TRUE: "TRUE" /* TRUE */,
+        FALSE: "FALSE" /* FALSE */,
+        STARTS: "STARTS" /* STARTS */,
+        ENDS: "ENDS" /* ENDS */,
+        CONTAINS: "CONTAINS" /* CONTAINS */,
+        WITH: "WITH" /* WITH */,
+        LIMIT: "LIMIT" /* LIMIT */,
+        ORDER: "ORDER" /* ORDER */,
+        BY: "BY" /* BY */,
+        ASC: "ASC" /* ASC */,
+        DESC: "DESC" /* DESC */
+      };
+      if (keyword && keywordMap[keyword]) {
+        tokens.push({
+          type: keywordMap[keyword],
+          value: keyword,
+          position: startPos
+        });
+        this.readIdentifier();
+        continue;
+      }
+      switch (this.currentChar) {
+        case "(":
+          tokens.push({
+            type: "LPAREN" /* LPAREN */,
+            value: "(",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ")":
+          tokens.push({
+            type: "RPAREN" /* RPAREN */,
+            value: ")",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "[":
+          tokens.push({
+            type: "LBRACKET" /* LBRACKET */,
+            value: "[",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "]":
+          tokens.push({
+            type: "RBRACKET" /* RBRACKET */,
+            value: "]",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "{":
+          tokens.push({
+            type: "LBRACE" /* LBRACE */,
+            value: "{",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "}":
+          tokens.push({
+            type: "RBRACE" /* RBRACE */,
+            value: "}",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "<":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "-") {
+            tokens.push({
+              type: "ARROW" /* ARROW */,
+              value: "<-",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "LTE" /* LTE */,
+              value: "<=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "LT" /* LT */,
+              value: "<",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "-":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === ">") {
+            tokens.push({
+              type: "ARROW" /* ARROW */,
+              value: "->",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "DASH" /* DASH */,
+              value: "-",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "=":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "~") {
+            tokens.push({
+              type: "REGEX_MATCH" /* REGEX_MATCH */,
+              value: "=~",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "EQUALS" /* EQUALS */,
+              value: "=",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case "!":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "NOT_EQUALS" /* NOT_EQUALS */,
+              value: "!=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            throw new Error(`Unexpected character: ! at position ${startPos}`);
+          }
+          break;
+        case ">":
+          if (this.position + 1 < this.input.length && this.input[this.position + 1] === "=") {
+            tokens.push({
+              type: "GTE" /* GTE */,
+              value: ">=",
+              position: startPos
+            });
+            this.advance();
+            this.advance();
+          } else {
+            tokens.push({
+              type: "GT" /* GT */,
+              value: ">",
+              position: startPos
+            });
+            this.advance();
+          }
+          break;
+        case ",":
+          tokens.push({
+            type: "COMMA" /* COMMA */,
+            value: ",",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ".":
+          tokens.push({
+            type: "DOT" /* DOT */,
+            value: ".",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "|":
+          tokens.push({
+            type: "PIPE" /* PIPE */,
+            value: "|",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case "*":
+          tokens.push({
+            type: "ASTERISK" /* ASTERISK */,
+            value: "*",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case ":":
+          tokens.push({
+            type: "LABEL" /* LABEL */,
+            value: ":",
+            position: startPos
+          });
+          this.advance();
+          break;
+        case '"':
+        case "'":
+          tokens.push({
+            type: "STRING" /* STRING */,
+            value: this.readString(),
+            position: startPos
+          });
+          break;
+        default:
+          if (/[0-9]/.test(this.currentChar)) {
+            tokens.push({
+              type: "NUMBER" /* NUMBER */,
+              value: this.readNumber(),
+              position: startPos
+            });
+          } else if (/[a-zA-Z_]/.test(this.currentChar)) {
+            tokens.push({
+              type: "IDENTIFIER" /* IDENTIFIER */,
+              value: this.readIdentifier(),
+              position: startPos
+            });
+          } else {
+            throw new Error(
+              `Unexpected character: ${this.currentChar} at position ${startPos}`
+            );
+          }
+      }
+    }
+    tokens.push({ type: "EOF" /* EOF */, value: "", position: this.position });
+    return tokens;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Lexer,
+  TokenType
+});