graphql 15.3.0 → 15.5.1

package/language/experimentalOnlineParser/onlineParser.js

@@ -0,0 +1,604 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnlineParser = exports.RuleKind = exports.TokenKind = void 0;
+
+var _lexer = require("../lexer.js");
+
+var _source = require("../source.js");
+
+var _grammar = _interopRequireDefault(require("./grammar.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var TokenKind = {
+  NAME: 'Name',
+  INT: 'Int',
+  FLOAT: 'Float',
+  STRING: 'String',
+  BLOCK_STRING: 'BlockString',
+  COMMENT: 'Comment',
+  PUNCTUATION: 'Punctuation',
+  EOF: '<EOF>',
+  INVALID: 'Invalid'
+};
+exports.TokenKind = TokenKind;
+var RuleKind = {
+  TOKEN_CONSTRAINT: 'TokenConstraint',
+  OF_TYPE_CONSTRAINT: 'OfTypeConstraint',
+  LIST_OF_TYPE_CONSTRAINT: 'ListOfTypeConstraint',
+  PEEK_CONSTRAINT: 'PeekConstraint',
+  CONSTRAINTS_SET: 'ConstraintsSet',
+  CONSTRAINTS_SET_ROOT: 'ConstraintsSetRoot',
+  RULE_NAME: 'RuleName',
+  INVALID: 'Invalid'
+};
+exports.RuleKind = RuleKind;
+
+var OnlineParser = /*#__PURE__*/function () {
+  function OnlineParser(source, state, config) {
+    var _config$tabSize;
+
+    this.state = state || OnlineParser.startState();
+    this._config = {
+      tabSize: (_config$tabSize = config === null || config === void 0 ? void 0 : config.tabSize) !== null && _config$tabSize !== void 0 ? _config$tabSize : 2
+    };
+    this._lexer = new _lexer.Lexer(new _source.Source(source));
+  }
+
+  OnlineParser.startState = function startState() {
+    return {
+      rules: [// $FlowFixMe[cannot-spread-interface]
+      _objectSpread(_objectSpread({
+        name: 'Document',
+        state: 'Document',
+        kind: 'ListOfTypeConstraint'
+      }, _grammar.default.Document), {}, {
+        expanded: false,
+        depth: 1,
+        step: 1
+      })],
+      name: null,
+      type: null,
+      levels: [],
+      indentLevel: 0,
+      kind: function kind() {
+        var _this$rules;
+
+        return ((_this$rules = this.rules[this.rules.length - 1]) === null || _this$rules === void 0 ? void 0 : _this$rules.state) || '';
+      },
+      step: function step() {
+        var _this$rules2;
+
+        return ((_this$rules2 = this.rules[this.rules.length - 1]) === null || _this$rules2 === void 0 ? void 0 : _this$rules2.step) || 0;
+      }
+    };
+  };
+
+  OnlineParser.copyState = function copyState(state) {
+    return {
+      name: state.name,
+      type: state.type,
+      rules: JSON.parse(JSON.stringify(state.rules)),
+      levels: [].concat(state.levels),
+      indentLevel: state.indentLevel,
+      kind: function kind() {
+        var _this$rules3;
+
+        return ((_this$rules3 = this.rules[this.rules.length - 1]) === null || _this$rules3 === void 0 ? void 0 : _this$rules3.state) || '';
+      },
+      step: function step() {
+        var _this$rules4;
+
+        return ((_this$rules4 = this.rules[this.rules.length - 1]) === null || _this$rules4 === void 0 ? void 0 : _this$rules4.step) || 0;
+      }
+    };
+  };
+
+  var _proto = OnlineParser.prototype;
+
+  _proto.sol = function sol() {
+    return this._lexer.source.locationOffset.line === 1 && this._lexer.source.locationOffset.column === 1;
+  };
+
+  _proto.parseToken = function parseToken() {
+    var rule = this._getNextRule();
+
+    if (this.sol()) {
+      this.state.indentLevel = Math.floor(this.indentation() / this._config.tabSize);
+    }
+
+    if (!rule) {
+      return {
+        kind: TokenKind.INVALID,
+        value: ''
+      };
+    }
+
+    var token;
+
+    if (this._lookAhead().kind === '<EOF>') {
+      return {
+        kind: TokenKind.EOF,
+        value: '',
+        ruleName: rule.name
+      };
+    }
+
+    switch (rule.kind) {
+      case RuleKind.TOKEN_CONSTRAINT:
+        token = this._parseTokenConstraint(rule);
+        break;
+
+      case RuleKind.LIST_OF_TYPE_CONSTRAINT:
+        token = this._parseListOfTypeConstraint(rule);
+        break;
+
+      case RuleKind.OF_TYPE_CONSTRAINT:
+        token = this._parseOfTypeConstraint(rule);
+        break;
+
+      case RuleKind.PEEK_CONSTRAINT:
+        token = this._parsePeekConstraint(rule);
+        break;
+
+      case RuleKind.CONSTRAINTS_SET_ROOT:
+        token = this._parseConstraintsSetRule(rule);
+        break;
+
+      default:
+        return {
+          kind: TokenKind.INVALID,
+          value: '',
+          ruleName: rule.name
+        };
+    }
+
+    if (token && token.kind === TokenKind.INVALID) {
+      if (rule.optional === true) {
+        this.state.rules.pop();
+      } else {
+        this._rollbackRule();
+      }
+
+      return this.parseToken() || token;
+    }
+
+    return token;
+  };
+
+  _proto.indentation = function indentation() {
+    var match = this._lexer.source.body.match(/\s*/);
+
+    var indent = 0;
+
+    if (match && match.length === 0) {
+      var whiteSpaces = match[0];
+      var pos = 0;
+
+      while (whiteSpaces.length > pos) {
+        if (whiteSpaces.charCodeAt(pos) === 9) {
+          indent += 2;
+        } else {
+          indent++;
+        }
+
+        pos++;
+      }
+    }
+
+    return indent;
+  };
+
+  _proto._parseTokenConstraint = function _parseTokenConstraint(rule) {
+    rule.expanded = true;
+
+    var token = this._lookAhead();
+
+    if (!this._matchToken(token, rule)) {
+      return {
+        kind: TokenKind.INVALID,
+        value: '',
+        tokenName: rule.tokenName,
+        ruleName: rule.name
+      };
+    }
+
+    this._advanceToken();
+
+    var parserToken = this._transformLexerToken(token, rule);
+
+    this._popMatchedRule(parserToken);
+
+    return parserToken;
+  };
+
+  _proto._parseListOfTypeConstraint = function _parseListOfTypeConstraint(rule) {
+    this._pushRule(_grammar.default[rule.listOfType], rule.depth + 1, rule.listOfType, 1, rule.state);
+
+    rule.expanded = true;
+    var token = this.parseToken();
+    return token;
+  };
+
+  _proto._parseOfTypeConstraint = function _parseOfTypeConstraint(rule) {
+    if (rule.expanded) {
+      this._popMatchedRule();
+
+      return this.parseToken();
+    }
+
+    this._pushRule(rule.ofType, rule.depth + 1, rule.tokenName, 1, rule.state);
+
+    rule.expanded = true;
+    var token = this.parseToken();
+    return token;
+  };
+
+  _proto._parsePeekConstraint = function _parsePeekConstraint(rule) {
+    if (rule.expanded) {
+      this._popMatchedRule();
+
+      return this.parseToken();
+    }
+
+    while (!rule.matched && rule.index < rule.peek.length - 1) {
+      rule.index++;
+      var constraint = rule.peek[rule.index];
+      var ifCondition = constraint.ifCondition;
+
+      if (typeof ifCondition === 'string') {
+        ifCondition = _grammar.default[ifCondition];
+      }
+
+      var token = this._lookAhead();
+
+      if (ifCondition && this._matchToken(token, ifCondition)) {
+        rule.matched = true;
+        rule.expanded = true;
+
+        this._pushRule(constraint.expect, rule.depth + 1, '', 1, rule.state);
+
+        token = this.parseToken();
+        return token;
+      }
+    }
+
+    return {
+      kind: TokenKind.INVALID,
+      value: '',
+      ruleName: rule.name
+    };
+  };
+
+  _proto._parseConstraintsSetRule = function _parseConstraintsSetRule(rule) {
+    if (rule.expanded) {
+      this._popMatchedRule();
+
+      return this.parseToken();
+    }
+
+    for (var index = rule.constraints.length - 1; index >= 0; index--) {
+      this._pushRule(rule.constraints[index], rule.depth + 1, '', index, rule.state);
+    }
+
+    rule.expanded = true;
+    return this.parseToken();
+  };
+
+  _proto._matchToken = function _matchToken(token, rule) {
+    if (typeof token.value === 'string') {
+      if (typeof rule.ofValue === 'string' && token.value !== rule.ofValue || Array.isArray(rule.oneOf) && !rule.oneOf.includes(token.value) || typeof rule.ofValue !== 'string' && !Array.isArray(rule.oneOf) && token.kind !== rule.token) {
+        return false;
+      }
+
+      return this._butNot(token, rule);
+    }
+
+    if (token.kind !== rule.token) {
+      return false;
+    }
+
+    return this._butNot(token, rule);
+  };
+
+  _proto._butNot = function _butNot(token, rule) {
+    var _this = this;
+
+    if (rule.butNot) {
+      if (Array.isArray(rule.butNot)) {
+        if (rule.butNot.reduce(function (matched, constraint) {
+          return matched || _this._matchToken(token, constraint);
+        }, false)) {
+          return false;
+        }
+
+        return true;
+      }
+
+      return !this._matchToken(token, rule.butNot);
+    }
+
+    return true;
+  };
+
+  _proto._transformLexerToken = function _transformLexerToken(lexerToken, rule) {
+    var token;
+    var ruleName = rule.name || '';
+    var tokenName = rule.tokenName || '';
+
+    if (lexerToken.kind === '<EOF>' || lexerToken.value !== undefined) {
+      token = {
+        kind: lexerToken.kind,
+        value: lexerToken.value || '',
+        tokenName: tokenName,
+        ruleName: ruleName
+      };
+
+      if (token.kind === TokenKind.STRING) {
+        token.value = "\"".concat(token.value, "\"");
+      } else if (token.kind === TokenKind.BLOCK_STRING) {
+        token.value = "\"\"\"".concat(token.value, "\"\"\"");
+      }
+    } else {
+      token = {
+        kind: TokenKind.PUNCTUATION,
+        value: lexerToken.kind,
+        tokenName: tokenName,
+        ruleName: ruleName
+      };
+
+      if (/^[{([]/.test(token.value)) {
+        if (this.state.indentLevel !== undefined) {
+          this.state.levels = this.state.levels.concat(this.state.indentLevel + 1);
+        }
+      } else if (/^[})\]]/.test(token.value)) {
+        this.state.levels.pop();
+      }
+    }
+
+    return token;
+  };
+
+  _proto._getNextRule = function _getNextRule() {
+    return this.state.rules[this.state.rules.length - 1] || null;
+  };
+
+  _proto._popMatchedRule = function _popMatchedRule(token) {
+    var rule = this.state.rules.pop();
+
+    if (!rule) {
+      return;
+    }
+
+    if (token && rule.kind === RuleKind.TOKEN_CONSTRAINT) {
+      var constraint = rule;
+
+      if (typeof constraint.definitionName === 'string') {
+        this.state.name = token.value || null;
+      } else if (typeof constraint.typeName === 'string') {
+        this.state.type = token.value || null;
+      }
+    }
+
+    var nextRule = this._getNextRule();
+
+    if (!nextRule) {
+      return;
+    }
+
+    if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.CONSTRAINTS_SET_ROOT) {
+      this.state.rules.pop();
+    }
+
+    if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT) {
+      nextRule.expanded = false;
+      nextRule.optional = true;
+    }
+  };
+
+  _proto._rollbackRule = function _rollbackRule() {
+    var _this2 = this;
+
+    if (!this.state.rules.length) {
+      return;
+    }
+
+    var popRule = function popRule() {
+      var lastPoppedRule = _this2.state.rules.pop();
+
+      if (lastPoppedRule.eatNextOnFail === true) {
+        _this2.state.rules.pop();
+      }
+    };
+
+    var poppedRule = this.state.rules.pop();
+
+    if (!poppedRule) {
+      return;
+    }
+
+    var popped = 0;
+
+    var nextRule = this._getNextRule();
+
+    while (nextRule && (poppedRule.kind !== RuleKind.LIST_OF_TYPE_CONSTRAINT || nextRule.expanded) && nextRule.depth > poppedRule.depth - 1) {
+      this.state.rules.pop();
+      popped++;
+      nextRule = this._getNextRule();
+    }
+
+    if (nextRule && nextRule.expanded) {
+      if (nextRule.optional === true) {
+        popRule();
+      } else {
+        if (nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT && popped === 1) {
+          this.state.rules.pop();
+          return;
+        }
+
+        this._rollbackRule();
+      }
+    }
+  };
+
+  _proto._pushRule = function _pushRule(baseRule, depth, name, step, state) {
+    var _this$_getNextRule, _this$_getNextRule2, _this$_getNextRule3, _this$_getNextRule4, _this$_getNextRule5, _this$_getNextRule6, _this$_getNextRule7, _this$_getNextRule8, _this$_getNextRule9, _this$_getNextRule10;
+
+    this.state.name = null;
+    this.state.type = null;
+    var rule = baseRule;
+
+    switch (this._getRuleKind(rule)) {
+      case RuleKind.RULE_NAME:
+        rule = rule;
+
+        this._pushRule(_grammar.default[rule], depth, (typeof name === 'string' ? name : undefined) || rule, step, state);
+
+        break;
+
+      case RuleKind.CONSTRAINTS_SET:
+        rule = rule;
+        this.state.rules.push({
+          name: name || '',
+          depth: depth,
+          expanded: false,
+          constraints: rule,
+          constraintsSet: true,
+          kind: RuleKind.CONSTRAINTS_SET_ROOT,
+          state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule = this._getNextRule()) === null || _this$_getNextRule === void 0 ? void 0 : _this$_getNextRule.state) || '',
+          step: typeof step === 'number' ? step : (((_this$_getNextRule2 = this._getNextRule()) === null || _this$_getNextRule2 === void 0 ? void 0 : _this$_getNextRule2.step) || 0) + 1
+        });
+        break;
+
+      case RuleKind.OF_TYPE_CONSTRAINT:
+        rule = rule;
+        this.state.rules.push({
+          name: name || '',
+          ofType: rule.ofType,
+          optional: Boolean(rule.optional),
+          butNot: rule.butNot,
+          eatNextOnFail: Boolean(rule.eatNextOnFail),
+          depth: depth,
+          expanded: false,
+          kind: RuleKind.OF_TYPE_CONSTRAINT,
+          state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule3 = this._getNextRule()) === null || _this$_getNextRule3 === void 0 ? void 0 : _this$_getNextRule3.state) || '',
+          step: typeof step === 'number' ? step : (((_this$_getNextRule4 = this._getNextRule()) === null || _this$_getNextRule4 === void 0 ? void 0 : _this$_getNextRule4.step) || 0) + 1
+        });
+        break;
+
+      case RuleKind.LIST_OF_TYPE_CONSTRAINT:
+        rule = rule;
+        this.state.rules.push({
+          listOfType: rule.listOfType,
+          optional: Boolean(rule.optional),
+          butNot: rule.butNot,
+          eatNextOnFail: Boolean(rule.eatNextOnFail),
+          name: name || '',
+          depth: depth,
+          expanded: false,
+          kind: RuleKind.LIST_OF_TYPE_CONSTRAINT,
+          state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule5 = this._getNextRule()) === null || _this$_getNextRule5 === void 0 ? void 0 : _this$_getNextRule5.state) || '',
+          step: typeof step === 'number' ? step : (((_this$_getNextRule6 = this._getNextRule()) === null || _this$_getNextRule6 === void 0 ? void 0 : _this$_getNextRule6.step) || 0) + 1
+        });
+        break;
+
+      case RuleKind.TOKEN_CONSTRAINT:
+        rule = rule;
+        this.state.rules.push({
+          token: rule.token,
+          ofValue: rule.ofValue,
+          oneOf: rule.oneOf,
+          definitionName: Boolean(rule.definitionName),
+          typeName: Boolean(rule.typeName),
+          optional: Boolean(rule.optional),
+          butNot: rule.butNot,
+          eatNextOnFail: Boolean(rule.eatNextOnFail),
+          name: name || '',
+          depth: depth,
+          expanded: false,
+          kind: RuleKind.TOKEN_CONSTRAINT,
+          state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule7 = this._getNextRule()) === null || _this$_getNextRule7 === void 0 ? void 0 : _this$_getNextRule7.state) || '',
+          step: typeof step === 'number' ? step : (((_this$_getNextRule8 = this._getNextRule()) === null || _this$_getNextRule8 === void 0 ? void 0 : _this$_getNextRule8.step) || 0) + 1
+        });
+        break;
+
+      case RuleKind.PEEK_CONSTRAINT:
+        rule = rule;
+        this.state.rules.push({
+          peek: rule.peek,
+          optional: Boolean(rule.optional),
+          butNot: rule.butNot,
+          eatNextOnFail: Boolean(rule.eatNextOnFail),
+          name: name || '',
+          depth: depth,
+          index: -1,
+          matched: false,
+          expanded: false,
+          kind: RuleKind.PEEK_CONSTRAINT,
+          state: (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule9 = this._getNextRule()) === null || _this$_getNextRule9 === void 0 ? void 0 : _this$_getNextRule9.state) || '',
+          step: typeof step === 'number' ? step : (((_this$_getNextRule10 = this._getNextRule()) === null || _this$_getNextRule10 === void 0 ? void 0 : _this$_getNextRule10.step) || 0) + 1
+        });
+        break;
+    }
+  };
+
+  _proto._getRuleKind = function _getRuleKind(rule) {
+    if (Array.isArray(rule)) {
+      return RuleKind.CONSTRAINTS_SET;
+    }
+
+    if (rule.constraintsSet === true) {
+      return RuleKind.CONSTRAINTS_SET_ROOT;
+    }
+
+    if (typeof rule === 'string') {
+      return RuleKind.RULE_NAME;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(rule, 'ofType')) {
+      return RuleKind.OF_TYPE_CONSTRAINT;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(rule, 'listOfType')) {
+      return RuleKind.LIST_OF_TYPE_CONSTRAINT;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(rule, 'peek')) {
+      return RuleKind.PEEK_CONSTRAINT;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(rule, 'token')) {
+      return RuleKind.TOKEN_CONSTRAINT;
+    }
+
+    return RuleKind.INVALID;
+  };
+
+  _proto._advanceToken = function _advanceToken() {
+    return this._lexer.advance();
+  };
+
+  _proto._lookAhead = function _lookAhead() {
+    try {
+      return this._lexer.lookahead();
+    } catch (err) {
+      return {
+        kind: TokenKind.INVALID,
+        value: ''
+      };
+    }
+  };
+
+  return OnlineParser;
+}();
+
+exports.OnlineParser = OnlineParser;