@valbuild/core 0.14.0 → 0.16.0

package/dist/index-cac9ecbd.cjs.prod.js

@@ -0,0 +1,456 @@
+'use strict';
+
+var SelectorProxy = require('./SelectorProxy-2af1b2b8.cjs.prod.js');
+var result = require('./result-26f67b40.cjs.prod.js');
+
+var WHITE_SPACE = ["\n", "\r", "\t", " "];
+function tokenize(input) {
+  var tokens = [];
+  var cursor = 0;
+  while (cursor < input.length) {
+    var _char = input[cursor];
+    var peek = input[cursor + 1];
+    // TODO: remove this not used any more
+    if (_char === "!" && peek === "(") {
+      tokens.push({
+        type: "!(",
+        span: [cursor, cursor + 1]
+      });
+      cursor += 2;
+    } else if (_char === "(") {
+      tokens.push({
+        type: "(",
+        span: [cursor, cursor]
+      });
+      cursor++;
+    } else if (_char === ")") {
+      tokens.push({
+        type: ")",
+        span: [cursor, cursor]
+      });
+      cursor++;
+    } else if (_char === "'" || _char === "}") {
+      var _start = cursor;
+      var value = "";
+      var unescapedValue = "";
+      var escaped = false;
+      if (_char === "}") {
+        tokens.push({
+          type: "}",
+          span: [cursor, cursor]
+        });
+      } else if (_char === "'") {
+        tokens.push({
+          type: "'",
+          span: [cursor, cursor]
+        });
+      }
+      while (cursor < input.length) {
+        if (_char === "\\") {
+          escaped = !escaped;
+        } else {
+          escaped = false;
+        }
+        if (peek === "'" && !escaped) {
+          cursor += 2;
+          break;
+        } else if (_char === "$" && peek === "{") {
+          cursor += 2;
+          break;
+        }
+        cursor++;
+        _char = input[cursor];
+        peek = input[cursor + 1];
+        if (!(_char === "$" && peek === "{") && cursor < input.length) {
+          if (!(_char === "\\" && !escaped // counter-intuitive, but escape just became false if this was a backslash we want to escape
+          )) {
+            value += _char;
+          }
+          unescapedValue += _char;
+        }
+      }
+      var cursorOffset = peek === "'" && !escaped ? 2 : _char === "$" && peek === "{" ? 3 : 1;
+      if (value) {
+        tokens.push(SelectorProxy._objectSpread2({
+          type: "string",
+          span: [_start + 1, cursor - cursorOffset],
+          value: value
+        }, unescapedValue !== value && {
+          unescapedValue: unescapedValue
+        }));
+      }
+      if (peek === "'" && !escaped) {
+        tokens.push({
+          type: "'",
+          span: [cursor - 1, cursor - 1]
+        });
+      } else if (_char === "$" && peek === "{") {
+        tokens.push({
+          type: "${",
+          span: [cursor - cursorOffset + 1, cursor - 1]
+        });
+      }
+    } else if (WHITE_SPACE.includes(_char)) {
+      var _start2 = cursor;
+      while (WHITE_SPACE.includes(input[cursor]) && cursor < input.length) {
+        cursor++;
+      }
+      tokens.push({
+        type: "ws",
+        span: [_start2, cursor - 1]
+      });
+    } else {
+      var _value = "";
+      var _start3 = cursor;
+      do {
+        _char = input[cursor];
+        peek = input[cursor + 1];
+        _value += _char;
+        cursor++;
+      } while (!WHITE_SPACE.includes(peek) && peek !== ")" && peek !== "'" && cursor < input.length);
+      tokens.push({
+        type: "token",
+        span: [_start3, cursor - 1],
+        value: _value
+      });
+    }
+  }
+  return [tokens, cursor];
+}
+
+var ParserError = /*#__PURE__*/SelectorProxy._createClass(function ParserError(message, span) {
+  SelectorProxy._classCallCheck(this, ParserError);
+  this.message = message;
+  this.span = span;
+});
+function parseTokens(inputTokens) {
+  var tokens = inputTokens.slice();
+  function slurpCall(first, isAnon) {
+    var _tokens$, _tokens$2, _tokens$3, _tokens$7, _tokens$8, _args$slice$0$span;
+    // peek
+    if (((_tokens$ = tokens[0]) === null || _tokens$ === void 0 ? void 0 : _tokens$.type) === "ws" && ((_tokens$2 = tokens[1]) === null || _tokens$2 === void 0 ? void 0 : _tokens$2.type) === ")" || ((_tokens$3 = tokens[0]) === null || _tokens$3 === void 0 ? void 0 : _tokens$3.type) === ")") {
+      slurpWs();
+      tokens.shift();
+      return result.ok(new SelectorProxy.Sym("()", [first.span[0], first.span[1] + 1]));
+    }
+    var args = [];
+    var completed = false;
+    while (!completed) {
+      var _res = slurp();
+      if (result.isOk(_res)) {
+        var _tokens$4, _tokens$5, _tokens$6;
+        args.push(_res.value);
+        completed = ((_tokens$4 = tokens[0]) === null || _tokens$4 === void 0 ? void 0 : _tokens$4.type) !== "ws" || ((_tokens$5 = tokens[0]) === null || _tokens$5 === void 0 ? void 0 : _tokens$5.type) === "ws" && ((_tokens$6 = tokens[1]) === null || _tokens$6 === void 0 ? void 0 : _tokens$6.type) === ")";
+      } else {
+        return _res;
+      }
+    }
+    if (((_tokens$7 = tokens[0]) === null || _tokens$7 === void 0 ? void 0 : _tokens$7.type) === "ws" && ((_tokens$8 = tokens[1]) === null || _tokens$8 === void 0 ? void 0 : _tokens$8.type) === ")") {
+      tokens.shift();
+    }
+    var last = tokens.shift();
+    if ((last === null || last === void 0 ? void 0 : last.type) !== ")") {
+      return result.err(new ParserError("unbalanced parens: missing a ')'", [first.span[0], first.span[1] + 1]));
+    }
+    return result.ok(new SelectorProxy.Call(args, isAnon, [first.span[0], ((_args$slice$0$span = args.slice(-1)[0].span) === null || _args$slice$0$span === void 0 ? void 0 : _args$slice$0$span[1]) || -1]));
+  }
+  function slurpWs() {
+    while (((_tokens$9 = tokens[0]) === null || _tokens$9 === void 0 ? void 0 : _tokens$9.type) === "ws") {
+      var _tokens$9;
+      tokens.shift();
+    }
+  }
+  function slurpTemplate(first) {
+    var children = [];
+    while (tokens.length > 0) {
+      var _tokens$10;
+      if (((_tokens$10 = tokens[0]) === null || _tokens$10 === void 0 ? void 0 : _tokens$10.type) === "'") {
+        break;
+      }
+      var nextToken = tokens.shift();
+      if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "${") {
+        var _res2 = slurp();
+        if (result.isOk(_res2)) {
+          children.push(_res2.value);
+          var _last = tokens.shift();
+          if (!_last) {
+            var _children$slice$0$spa;
+            return result.err(new ParserError("unbalanced string template: missing a '}'", [first.span[0], (_children$slice$0$spa = children.slice(-1)[0].span) === null || _children$slice$0$spa === void 0 ? void 0 : _children$slice$0$spa[1]]));
+          } else if (_last.type !== "}") {
+            return result.err(new ParserError("unbalanced string template: expected '}'", _last.span));
+          }
+        } else {
+          return _res2;
+        }
+      } else if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "string") {
+        children.push(new SelectorProxy.StringLiteral(nextToken.unescapedValue || nextToken.value || "", nextToken.span));
+      }
+    }
+    var last = tokens.shift();
+    if (!last) {
+      var _children$slice$0$spa2;
+      return result.err(new ParserError("unbalanced string template: missing a '''", [first.span[0], (_children$slice$0$spa2 = children.slice(-1)[0].span) === null || _children$slice$0$spa2 === void 0 ? void 0 : _children$slice$0$spa2[1]]));
+    } else if (last.type !== "'") {
+      return result.err(new ParserError("unbalanced string template: expected '''", last.span));
+    }
+    return result.ok(new SelectorProxy.StringTemplate(children, [first.span[0], last.span[1]]));
+  }
+  function slurpString(first) {
+    var _tokens$11, _tokens$12, _tokens$13;
+    if (((_tokens$11 = tokens[0]) === null || _tokens$11 === void 0 ? void 0 : _tokens$11.type) === "string" && ((_tokens$12 = tokens[1]) === null || _tokens$12 === void 0 ? void 0 : _tokens$12.type) === "'") {
+      var stringToken = tokens.shift();
+      var last = tokens.shift();
+      if (!last || !stringToken) {
+        throw Error("Unexpected error: stringToken or last is undefined");
+      }
+      return result.ok(new SelectorProxy.StringLiteral(stringToken.unescapedValue || stringToken.value || "", [first.span[0], last.span[1]]));
+    } else if (((_tokens$13 = tokens[0]) === null || _tokens$13 === void 0 ? void 0 : _tokens$13.type) === "'") {
+      var _last2 = tokens.shift();
+      if (!_last2) {
+        throw Error("Unexpected error: last is undefined");
+      }
+      return result.ok(new SelectorProxy.StringLiteral("", [first.span[0], _last2.span[1]]));
+    } else {
+      return slurpTemplate(first);
+    }
+  }
+  function slurp() {
+    slurpWs();
+    var first = tokens.shift();
+    if (!first) {
+      return result.err(new ParserError("expected '(', '!(', string or literal", [0, 0]));
+    }
+    if (first.type === "(" || first.type === "!(") {
+      return slurpCall(first, first.type === "!(");
+    } else if (first.type === "'") {
+      return slurpString(first);
+    } else if (first.type === "token") {
+      var _first$value, _first$value2, _first$value3, _first$value4, _first$value5, _first$value6;
+      if ((_first$value = first.value) !== null && _first$value !== void 0 && _first$value.includes("(") || (_first$value2 = first.value) !== null && _first$value2 !== void 0 && _first$value2.includes(")")) {
+        return result.err(new ParserError("unexpected token: '(' and ')' are not allowed in tokens", first.span));
+      }
+      if ((_first$value3 = first.value) !== null && _first$value3 !== void 0 && _first$value3.includes("'")) {
+        return result.err(new ParserError('unexpected token: "\'" is not allowed in tokens', first.span));
+      }
+      if ((_first$value4 = first.value) !== null && _first$value4 !== void 0 && _first$value4.includes(".")) {
+        return result.err(new ParserError('unexpected token: "." is not allowed in tokens', first.span));
+      }
+      if ((_first$value5 = first.value) !== null && _first$value5 !== void 0 && _first$value5.includes("{") || (_first$value6 = first.value) !== null && _first$value6 !== void 0 && _first$value6.includes("}")) {
+        return result.err(new ParserError("unexpected token: '{' and '}' are not allowed in tokens", first.span));
+      }
+      return result.ok(new SelectorProxy.Sym(first.value || "", first.span));
+    } else {
+      return result.err(new ParserError("expected '(', '!(' or literal or token".concat(first.value || first.type ? ", got: '".concat(first.value || first.type, "'") : ""), first.span));
+    }
+  }
+  var res = slurp();
+  slurpWs();
+  if (result.isErr(res)) {
+    return res;
+  }
+  if (tokens.length > 0) {
+    return result.err(new ParserError("expected end of input, superfluous tokens", [tokens[0].span[0], tokens.slice(-1)[0].span[1]]));
+  }
+  return res;
+}
+function parse(input) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  var _tokenize = tokenize(input),
+    _tokenize2 = SelectorProxy._slicedToArray(_tokenize, 2),
+    tokens = _tokenize2[0];
+    _tokenize2[1]; // TODO: we can use cursor to improve error messages / spans
+  return parseTokens(tokens);
+}
+
+var EvalError = /*#__PURE__*/function () {
+  function EvalError(message, expr) {
+    SelectorProxy._classCallCheck(this, EvalError);
+    this.message = message;
+    this.expr = expr;
+  }
+  SelectorProxy._createClass(EvalError, [{
+    key: "toString",
+    value: function toString() {
+      return "".concat(this.message, " in: ").concat(this.expr.transpile());
+    }
+  }]);
+  return EvalError;
+}();
+var MAX_STACK_SIZE = 100; // an arbitrary semi-large number
+function evaluateSync(expr, getSource, stack) {
+  // TODO: amount of evaluates should be limited?
+  if (stack.length > MAX_STACK_SIZE) {
+    throw new EvalError("Stack overflow. Final frames: ".concat(stack.slice(-10).map(function (frame, i) {
+      return frame.map(function (s, j) {
+        return "@[".concat(i, ",").concat(j, "]: ").concat(JSON.stringify(s));
+      }).join(", ");
+    }).join(" -> ")), expr);
+  }
+  if (expr instanceof SelectorProxy.Call) {
+    if (expr.children[0] instanceof SelectorProxy.Sym) {
+      if (expr.children[0].value === "val") {
+        if (expr.isAnon) {
+          throw new EvalError("cannot call 'val' as anonymous function", expr);
+        }
+        if (expr.children[1] instanceof SelectorProxy.StringLiteral) {
+          var _path = expr.children[1].value;
+          return SelectorProxy.newSelectorProxy(getSource(_path), _path);
+        } else {
+          throw new EvalError("argument of 'val' must be a string literal", expr);
+        }
+      } else if (expr.children[0].value === "json") {
+        if (expr.children.length !== 2) {
+          throw new EvalError("must call 'json' with exactly one argument", expr);
+        }
+        var value = evaluateSync(expr.children[1], getSource, stack);
+        var valObj = value[SelectorProxy.SourceOrExpr];
+        var valPath = value[SelectorProxy.Path];
+        if (typeof valObj !== "string") {
+          throw new EvalError("cannot parse JSON: ".concat(JSON.stringify(valObj), ", expected string"), expr.children[1]);
+        }
+        try {
+          var serialized = JSON.parse(valObj);
+          if (SelectorProxy.isSerializedVal(serialized)) {
+            return SelectorProxy.newSelectorProxy(serialized.val, serialized.valPath);
+          }
+          var parsedValue = SelectorProxy.newSelectorProxy(JSON.parse(valObj), valPath);
+          return parsedValue;
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            throw new EvalError("cannot parse JSON: ".concat(valObj, ", ").concat(e.message, " - value: ").concat(JSON.stringify(value)), expr.children[1]);
+          }
+          throw e;
+        }
+      } else if (expr.children[0].value === "stringify") {
+        // TODO: remove stringify
+        if (expr.children.length !== 2) {
+          throw new EvalError("must call 'stringify' with exactly one argument", expr);
+        }
+        var res = evaluateSync(expr.children[1], getSource, stack);
+        return SelectorProxy.newSelectorProxy(JSON.stringify(res[SelectorProxy.SourceOrExpr]));
+      }
+    }
+    var prop = evaluateSync(expr.children[0], getSource, stack)[SelectorProxy.SourceOrExpr];
+    if (expr.children.length === 1) {
+      // TODO: return if literal only?
+      return SelectorProxy.newSelectorProxy(prop);
+    }
+    var obj = evaluateSync(expr.children[1], getSource, stack);
+    if (typeof prop !== "string" && typeof prop !== "number") {
+      throw new EvalError("cannot access ".concat(JSON.stringify(obj), " with property ").concat(JSON.stringify(prop), ": is not a string or number"), expr);
+    }
+    if (prop in obj) {
+      if (expr.isAnon) {
+        // anon functions:
+        var maybeFunction = obj[prop];
+        if (typeof maybeFunction !== "function") {
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required higher ordered function got ").concat(SelectorProxy._typeof(obj[prop])), expr);
+        }
+        if (expr.children[0] instanceof SelectorProxy.Sym) {
+          return maybeFunction(function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            return evaluateSync(expr.children[2], getSource, stack.concat([args]));
+          });
+        } else {
+          throw new EvalError("cannot call an expression that is not a symbol, got: '".concat(expr.children[0].type, "'"), expr);
+        }
+      } else {
+        // non-anon functions:
+        if (expr.children[0] instanceof SelectorProxy.Sym) {
+          if (expr.children[0].value === "val") {
+            if (expr.children[1] instanceof SelectorProxy.StringLiteral) {
+              var _path2 = expr.children[1].value;
+              return SelectorProxy.newSelectorProxy(getSource(_path2), _path2);
+            } else {
+              throw new EvalError("argument of 'val' must be a string literal", expr);
+            }
+          }
+        }
+        var args = expr.children.slice(2);
+        if (args.length > 0) {
+          var _maybeFunction = obj[prop];
+          if (typeof _maybeFunction !== "function") {
+            throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required function got ").concat(SelectorProxy._typeof(obj[prop])), expr);
+          }
+          return _maybeFunction.apply(void 0, SelectorProxy._toConsumableArray(args.map(function (arg) {
+            return evaluateSync(arg, getSource, stack);
+          })));
+        }
+        var maybeValue = obj[prop];
+        if (typeof maybeValue === "function") {
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required value got ").concat(SelectorProxy._typeof(obj[prop])), expr);
+        }
+        return maybeValue;
+      }
+    }
+  } else if (expr instanceof SelectorProxy.Sym) {
+    if (expr.value.startsWith("@")) {
+      var _stack$Number;
+      var _expr$value$slice$spl = expr.value.slice(2, -1).split(","),
+        _expr$value$slice$spl2 = SelectorProxy._slicedToArray(_expr$value$slice$spl, 3),
+        i = _expr$value$slice$spl2[0],
+        j = _expr$value$slice$spl2[1],
+        rest = _expr$value$slice$spl2[2];
+      if (rest) {
+        throw new EvalError("cannot access stack: too many indices", expr);
+      }
+      var stackValue = (_stack$Number = stack[Number(i)]) === null || _stack$Number === void 0 ? void 0 : _stack$Number[Number(j)];
+      if (stackValue === undefined) {
+        throw new EvalError("cannot access stack: out of bounds", expr);
+      }
+      return stackValue;
+    } else if (expr.value === "()") {
+      return SelectorProxy.newSelectorProxy(null);
+    }
+    return SelectorProxy.newSelectorProxy(expr.value);
+  } else if (expr instanceof SelectorProxy.StringLiteral) {
+    return SelectorProxy.newSelectorProxy(expr.value);
+  } else if (expr instanceof SelectorProxy.StringTemplate) {
+    return SelectorProxy.newSelectorProxy(expr.children.map(function (child) {
+      if (child instanceof SelectorProxy.Sym && child.value === "()") {
+        return "null";
+      }
+      var evalRes = evaluateSync(child, getSource, stack);
+      if (child.type === "StringLiteral" || child.type === "StringTemplate") {
+        return evalRes[SelectorProxy.SourceOrExpr];
+      }
+      if (SelectorProxy.Path in evalRes) {
+        // a selector, so serialize to Val
+        return JSON.stringify({
+          val: evalRes[SelectorProxy.SourceOrExpr],
+          valPath: evalRes[SelectorProxy.Path]
+        });
+      }
+      return JSON.stringify(evalRes[SelectorProxy.SourceOrExpr]);
+    }).join(""));
+  }
+  throw new EvalError("could not evaluate", expr);
+}
+function evaluate(expr, source, stack) {
+  try {
+    return result.ok(evaluateSync(expr, source, stack));
+  } catch (err) {
+    if (err instanceof EvalError) {
+      return result.err(err);
+    }
+    throw err;
+  }
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  parse: parse,
+  Call: SelectorProxy.Call,
+  Expr: SelectorProxy.Expr,
+  NilSym: SelectorProxy.NilSym,
+  StringLiteral: SelectorProxy.StringLiteral,
+  StringTemplate: SelectorProxy.StringTemplate,
+  Sym: SelectorProxy.Sym,
+  evaluate: evaluate
+});
+
+exports.evaluate = evaluate;
+exports.index = index;
+exports.parse = parse;