@airtasker/form-schema-compiler/lib/tokenizers/utils.js

a form schema compiler

"use strict";

exports.__esModule = true;
exports.createPeekAndNext = exports.isBraceEnd = exports.isBraceStart = exports.readWhileWithEscaped = exports.readEscaped = exports.readWhile = exports.isBackQuote = exports.isWhitespace = exports.isStringStart = exports.isRegexpStart = exports.isPunctuation = exports.isId = exports.isIdStart = exports.isDigit = exports.isOperatorStart = exports.isNull = exports.isOperatorChar = exports.isKeyword = exports.isOperatorString = exports.isBoolean = undefined;

var _flatten = require("lodash/flatten");

var _flatten2 = _interopRequireDefault(_flatten);

var _const = require("../const");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var isBoolean = exports.isBoolean = function isBoolean(str) {
  return _const.BOOLEANS.includes(str);
};

var operatorStrings = Object.values(_const.OPERATORS);

var isOperatorString = exports.isOperatorString = function isOperatorString(str) {
  return operatorStrings.includes(str);
};

var isKeyword = exports.isKeyword = function isKeyword(str) {
  return _const.KEYWORDS.includes(str);
};

var operatorChars = [_const.OPERATORS.Add, _const.OPERATORS.Subtract, _const.OPERATORS.Multiply, _const.OPERATORS.Divide, _const.OPERATORS.Assign];

var isOperatorChar = exports.isOperatorChar = function isOperatorChar(ch) {
  return operatorChars.includes(ch);
};

var isNull = exports.isNull = function isNull(str) {
  return str === "null";
};

var operatorStartChars = [_const.OPERATORS.GreaterThan, _const.OPERATORS.LessThan];

var isOperatorStart = exports.isOperatorStart = function isOperatorStart(ch) {
  return operatorStartChars.includes(ch);
};

var digitChars = "0123456789";

var isDigit = exports.isDigit = function isDigit(ch) {
  return digitChars.includes(ch);
};

var isIdStart = exports.isIdStart = function isIdStart(ch) {
  return /[a-z_]/i.test(ch);
};

var isId = exports.isId = function isId(ch) {
  return isIdStart(ch) || isDigit(ch);
};

var punctuationChars = (0, _flatten2["default"])(Object.values(_const.PUNCTUATIONS));

var isPunctuation = exports.isPunctuation = function isPunctuation(ch) {
  return punctuationChars.includes(ch);
};

var isRegexpStart = exports.isRegexpStart = function isRegexpStart(ch) {
  return ch === "/";
};

var isStringStart = exports.isStringStart = function isStringStart(ch) {
  return ch === "'" || ch === '"';
};

var whitespaceChars = " \t\n\r";

var isWhitespace = exports.isWhitespace = function isWhitespace(ch) {
  return whitespaceChars.includes(ch);
};

var isBackQuote = exports.isBackQuote = function isBackQuote(ch) {
  return ch === _const.PUNCTUATIONS.BackQuote;
};
/**
 * concat input stream chunk until a failure predicate
 * @param inputStream
 * @param predicate
 * @returns {string}
 */


var readWhile = exports.readWhile = function readWhile(inputStream, predicate) {
  var str = "";

  while (!inputStream.eof() && predicate(inputStream.peek())) {
    str += inputStream.next();
  }

  return str;
};
/**
 * concat input stream chunk until a truthy shouldStop
 * Escape EVERY char next to '\'
 * @param inputStream
 * @param shouldStop(char) callback
 * @returns {string}
 */


var readEscaped = exports.readEscaped = function readEscaped(inputStream, shouldStop) {
  var escaped = false;
  var str = "";
  var stringEnded = false;

  while (!inputStream.eof()) {
    var ch = inputStream.peek();

    if (escaped) {
      str += ch;
      escaped = false;
    } else if (ch === "\\") {
      escaped = true;
    } else if (shouldStop(ch)) {
      return str;
    } else {
      str += ch;
    }

    inputStream.next();
  }

  inputStream.croak('input stream ended with no close symbol');
};
/**
 * concat input stream chunk until shouldStop() return true.
 * Will not check a char next to '\'
 * @param inputStream
 * @param shouldStop(char) callback return concatenation if true
 * @param removeEscapeWhenEscaped boolean if true will remove escape char if escaped
 * @returns {string}
 */


var readWhileWithEscaped = exports.readWhileWithEscaped = function readWhileWithEscaped(inputStream, shouldStop) {
  var removeEscapeWhenEscaped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var escaped = false;
  var str = "";

  while (!inputStream.eof()) {
    var ch = inputStream.next();
    var stop = shouldStop(ch);

    if (!escaped && stop) {
      break;
    }

    if (escaped && stop && removeEscapeWhenEscaped) {
      str = str.substr(0, str.length - 1);
    }

    if (!escaped && shouldStop(ch)) {
      break;
    }

    str += ch;
    escaped = ch === "\\" && !escaped;
  }

  return str;
};

var isBraceStart = exports.isBraceStart = function isBraceStart(ch) {
  return ch === _const.PUNCTUATIONS.Braces[0];
};

var isBraceEnd = exports.isBraceEnd = function isBraceEnd(ch) {
  return ch === _const.PUNCTUATIONS.Braces[1];
};
/**
 * peek, next, queue
 * peek will return current token without moving index
 * next will return current token and moving index
 * queue will store all previous tokens.
 * @param nextFn
 * @param queueSize
 * @returns {{peek: peek, next: next, queue: Array}}
 */


var createPeekAndNext = exports.createPeekAndNext = function createPeekAndNext(nextFn) {
  var queueSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  var current;
  var queue = [];

  function next() {
    var token = current;
    current = null;

    if (token) {
      return token;
    }

    var result = nextFn();

    if (queueSize) {
      queue.push(result);

      if (queue.length > queueSize) {
        queue.shift();
      }
    }

    return result;
  }

  function peek() {
    if (!current) {
      current = next();
    }

    return current;
  }

  return {
    peek: peek,
    next: next,
    queue: queue
  };
};