@valbuild/core 0.16.0 → 0.17.0

package/dist/{index-2fff5ca8.cjs.dev.js → index-486c7fbf.cjs.dev.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var SelectorProxy = require('./SelectorProxy-873782a5.cjs.dev.js');
+var index$1 = require('./index-a6e642dd.cjs.dev.js');
 var result = require('./result-48320acd.cjs.dev.js');
 
 var WHITE_SPACE = ["\n", "\r", "\t", " "];
@@ -71,7 +71,7 @@ function tokenize(input) {
       }
       var cursorOffset = peek === "'" && !escaped ? 2 : _char === "$" && peek === "{" ? 3 : 1;
       if (value) {
-        tokens.push(SelectorProxy._objectSpread2({
+        tokens.push(index$1._objectSpread2({
           type: "string",
           span: [_start + 1, cursor - cursorOffset],
           value: value
@@ -118,8 +118,8 @@ function tokenize(input) {
   return [tokens, cursor];
 }
 
-var ParserError = /*#__PURE__*/SelectorProxy._createClass(function ParserError(message, span) {
-  SelectorProxy._classCallCheck(this, ParserError);
+var ParserError = /*#__PURE__*/index$1._createClass(function ParserError(message, span) {
+  index$1._classCallCheck(this, ParserError);
   this.message = message;
   this.span = span;
 });
@@ -131,7 +131,7 @@ function parseTokens(inputTokens) {
     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]));
+      return result.ok(new index$1.Sym("()", [first.span[0], first.span[1] + 1]));
     }
     var args = [];
     var completed = false;
@@ -152,7 +152,7 @@ function parseTokens(inputTokens) {
     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]));
+    return result.ok(new index$1.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") {
@@ -183,7 +183,7 @@ function parseTokens(inputTokens) {
           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));
+        children.push(new index$1.StringLiteral(nextToken.unescapedValue || nextToken.value || "", nextToken.span));
       }
     }
     var last = tokens.shift();
@@ -193,7 +193,7 @@ function parseTokens(inputTokens) {
     } 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]]));
+    return result.ok(new index$1.StringTemplate(children, [first.span[0], last.span[1]]));
   }
   function slurpString(first) {
     var _tokens$11, _tokens$12, _tokens$13;
@@ -203,13 +203,13 @@ function parseTokens(inputTokens) {
       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]]));
+      return result.ok(new index$1.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]]));
+      return result.ok(new index$1.StringLiteral("", [first.span[0], _last2.span[1]]));
     } else {
       return slurpTemplate(first);
     }
@@ -238,7 +238,7 @@ function parseTokens(inputTokens) {
       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));
+      return result.ok(new index$1.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));
     }
@@ -256,19 +256,207 @@ function parseTokens(inputTokens) {
 function parse(input) {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   var _tokenize = tokenize(input),
-    _tokenize2 = SelectorProxy._slicedToArray(_tokenize, 2),
+    _tokenize2 = index$1._slicedToArray(_tokenize, 2),
     tokens = _tokenize2[0];
     _tokenize2[1]; // TODO: we can use cursor to improve error messages / spans
   return parseTokens(tokens);
 }
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+/**
+ * Selectors can be used to select parts of a Val module.
+ * Unlike queries, joins, aggregates etc is and will not be supported.
+ *
+ * They are designed to be be used as if they were "normal" JSON data,
+ * though some concessions had to be made because of TypeScript limitations.
+ *
+ * Selectors works equally on source content, defined in code, and remote content.
+ *
+ * @example
+ * // Select the title of a document
+ * const titles = useVal(docsVal.map((doc) => doc.title));
+ *
+ * @example
+ * // Match on a union type
+ * const titles = useVal(docsVal.map((doc) => doc.fold("type")({
+ *   newsletter: (newsletter) => newsletter.title,
+ *   email: (email) => email.subject,
+ * }));
+ *
+ */
+
+/**
+ * @internal
+ */
+var GetSchema = Symbol("GetSchema");
+/**
+/**
+ * @internal
+ */
+var Path = Symbol("Path");
+/**
+ * @internal
+ */
+var SourceOrExpr = Symbol("SourceOrExpr");
+
+/**
+ * Use this type to convert types that accepts both Source and Selectors
+ *
+ * An example would be where literals are supported like in most higher order functions (e.g. map in array)
+ **/
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function _andThen(f, source, path) {
+  if (source) {
+    return newSelectorProxy(f(newSelectorProxy(source, path)));
+  }
+  return newSelectorProxy(source, path);
+}
+function isSelector(source) {
+  return index$1._typeof(source) === "object" && source !== null && (SourceOrExpr in source || Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (index$1._typeof(source) === "object") {
+    if (isSelector(source)) {
+      return source;
+    } else if (index$1.isSerializedVal(source)) {
+      return newSelectorProxy(source.val, source.valPath);
+    }
+  }
+  if (source && source[index$1.FILE_REF_PROP] && source[index$1.VAL_EXTENSION] === "file") {
+    var fileRef = source[index$1.FILE_REF_PROP];
+    if (typeof fileRef !== "string") {
+      throw Error("Invalid file ref: " + fileRef);
+    }
+    return newSelectorProxy(index$1.convertFileSource(source), path, moduleSchema);
+  }
+  switch (index$1._typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(index$1._typeof(source), ": ").concat(source));
+    case "object":
+      // Handles both objects and arrays!
+      if (source !== null) {
+        return new Proxy(source, {
+          // TODO: see proxy docs if we want more traps
+          has: function has(target, prop) {
+            if (prop === SourceOrExpr) {
+              return true;
+            }
+            if (prop === Path) {
+              return true;
+            }
+            if (prop === "andThen") {
+              return true;
+            }
+            if (prop === GetSchema) {
+              return true;
+            }
+            return prop in target;
+          },
+          get: function get(target, prop) {
+            if (prop === SourceOrExpr) {
+              return source;
+            }
+            if (prop === Path) {
+              return path;
+            }
+            if (prop === GetSchema) {
+              return moduleSchema;
+            }
+            if (prop === "andThen") {
+              return function (f) {
+                return _andThen(f, source, path);
+              };
+            }
+            if (Array.isArray(target)) {
+              if (prop === "filter") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    return newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+                  }).filter(function (a) {
+                    if (f && f instanceof index$1.Schema) {
+                      return f.assert(unValify(a));
+                    } else {
+                      return unValify(f(a));
+                    }
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              } else if (prop === "map") {
+                return function (f) {
+                  var filtered = target.map(function (a, i) {
+                    var valueOrSelector = f(newSelectorProxy(a, createValPathOfItem(path, i), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item), newSelectorProxy(i));
+                    if (isSelector(valueOrSelector)) {
+                      return valueOrSelector;
+                    }
+                    return newSelectorProxy(valueOrSelector);
+                  });
+                  return newSelectorProxy(filtered, path, moduleSchema);
+                };
+              }
+            }
+            if (Array.isArray(target) && prop === "length") {
+              return newSelectorProxy(target.length);
+            }
+            var reflectedValue = Reflect.get(target, prop);
+            if (hasOwn(source, prop)) {
+              if (!Number.isNaN(Number(prop))) {
+                return newSelectorProxy(reflectedValue, createValPathOfItem(path, Number(prop)), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.item);
+              }
+              return newSelectorProxy(reflectedValue, createValPathOfItem(path, prop), moduleSchema === null || moduleSchema === void 0 ? void 0 : moduleSchema.items[prop]);
+            }
+            return reflectedValue;
+          }
+        });
+      }
+    // intentional fallthrough
+    // eslint-disable-next-line no-fallthrough
+    default:
+      return _ref = {
+        eq: function eq(other) {
+          var otherValue = other;
+          if (isSelector(other)) {
+            otherValue = other[SourceOrExpr];
+            if (otherValue instanceof index$1.Expr) {
+              throw Error("TODO: Cannot evaluate equality with an Expr");
+            }
+          }
+          return newSelectorProxy(source === otherValue, undefined);
+        },
+        andThen: function andThen(f) {
+          return _andThen(f, source === undefined ? null : source, path);
+        }
+      }, index$1._defineProperty(_ref, SourceOrExpr, source === undefined ? null : source), index$1._defineProperty(_ref, Path, path), index$1._defineProperty(_ref, GetSchema, moduleSchema), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (index$1._typeof(prop) === "symbol") {
+    throw Error("Cannot create val path of array item with symbol prop: ".concat(prop.toString()));
+  }
+  return arrayPath && "".concat(arrayPath, ".").concat(JSON.stringify(prop));
+}
+
+// TODO: could we do .val on the objects instead?
+function unValify(valueOrSelector) {
+  if (index$1._typeof(valueOrSelector) === "object" && (SourceOrExpr in valueOrSelector || Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[SourceOrExpr];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
 var EvalError = /*#__PURE__*/function () {
   function EvalError(message, expr) {
-    SelectorProxy._classCallCheck(this, EvalError);
+    index$1._classCallCheck(this, EvalError);
     this.message = message;
     this.expr = expr;
   }
-  SelectorProxy._createClass(EvalError, [{
+  index$1._createClass(EvalError, [{
     key: "toString",
     value: function toString() {
       return "".concat(this.message, " in: ").concat(this.expr.transpile());
@@ -286,15 +474,15 @@ function evaluateSync(expr, getSource, stack) {
       }).join(", ");
     }).join(" -> ")), expr);
   }
-  if (expr instanceof SelectorProxy.Call) {
-    if (expr.children[0] instanceof SelectorProxy.Sym) {
+  if (expr instanceof index$1.Call) {
+    if (expr.children[0] instanceof index$1.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) {
+        if (expr.children[1] instanceof index$1.StringLiteral) {
           var _path = expr.children[1].value;
-          return SelectorProxy.newSelectorProxy(getSource(_path), _path);
+          return newSelectorProxy(getSource(_path), _path);
         } else {
           throw new EvalError("argument of 'val' must be a string literal", expr);
         }
@@ -303,17 +491,17 @@ function evaluateSync(expr, getSource, stack) {
           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];
+        var valObj = value[SourceOrExpr];
+        var valPath = value[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);
+          if (index$1.isSerializedVal(serialized)) {
+            return newSelectorProxy(serialized.val, serialized.valPath);
           }
-          var parsedValue = SelectorProxy.newSelectorProxy(JSON.parse(valObj), valPath);
+          var parsedValue = newSelectorProxy(JSON.parse(valObj), valPath);
           return parsedValue;
         } catch (e) {
           if (e instanceof SyntaxError) {
@@ -327,13 +515,13 @@ function evaluateSync(expr, getSource, stack) {
           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]));
+        return newSelectorProxy(JSON.stringify(res[SourceOrExpr]));
       }
     }
-    var prop = evaluateSync(expr.children[0], getSource, stack)[SelectorProxy.SourceOrExpr];
+    var prop = evaluateSync(expr.children[0], getSource, stack)[SourceOrExpr];
     if (expr.children.length === 1) {
       // TODO: return if literal only?
-      return SelectorProxy.newSelectorProxy(prop);
+      return newSelectorProxy(prop);
     }
     var obj = evaluateSync(expr.children[1], getSource, stack);
     if (typeof prop !== "string" && typeof prop !== "number") {
@@ -344,9 +532,9 @@ function evaluateSync(expr, getSource, stack) {
         // 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);
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required higher ordered function got ").concat(index$1._typeof(obj[prop])), expr);
         }
-        if (expr.children[0] instanceof SelectorProxy.Sym) {
+        if (expr.children[0] instanceof index$1.Sym) {
           return maybeFunction(function () {
             for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
               args[_key] = arguments[_key];
@@ -358,11 +546,11 @@ function evaluateSync(expr, getSource, stack) {
         }
       } else {
         // non-anon functions:
-        if (expr.children[0] instanceof SelectorProxy.Sym) {
+        if (expr.children[0] instanceof index$1.Sym) {
           if (expr.children[0].value === "val") {
-            if (expr.children[1] instanceof SelectorProxy.StringLiteral) {
+            if (expr.children[1] instanceof index$1.StringLiteral) {
               var _path2 = expr.children[1].value;
-              return SelectorProxy.newSelectorProxy(getSource(_path2), _path2);
+              return newSelectorProxy(getSource(_path2), _path2);
             } else {
               throw new EvalError("argument of 'val' must be a string literal", expr);
             }
@@ -372,24 +560,24 @@ function evaluateSync(expr, getSource, stack) {
         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);
+            throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required function got ").concat(index$1._typeof(obj[prop])), expr);
           }
-          return _maybeFunction.apply(void 0, SelectorProxy._toConsumableArray(args.map(function (arg) {
+          return _maybeFunction.apply(void 0, index$1._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);
+          throw new EvalError("cannot access property ".concat(JSON.stringify(prop), " of ").concat(JSON.stringify(obj), ": required value got ").concat(index$1._typeof(obj[prop])), expr);
         }
         return maybeValue;
       }
     }
-  } else if (expr instanceof SelectorProxy.Sym) {
+  } else if (expr instanceof index$1.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),
+        _expr$value$slice$spl2 = index$1._slicedToArray(_expr$value$slice$spl, 3),
         i = _expr$value$slice$spl2[0],
         j = _expr$value$slice$spl2[1],
         rest = _expr$value$slice$spl2[2];
@@ -402,28 +590,28 @@ function evaluateSync(expr, getSource, stack) {
       }
       return stackValue;
     } else if (expr.value === "()") {
-      return SelectorProxy.newSelectorProxy(null);
+      return 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 newSelectorProxy(expr.value);
+  } else if (expr instanceof index$1.StringLiteral) {
+    return newSelectorProxy(expr.value);
+  } else if (expr instanceof index$1.StringTemplate) {
+    return newSelectorProxy(expr.children.map(function (child) {
+      if (child instanceof index$1.Sym && child.value === "()") {
         return "null";
       }
       var evalRes = evaluateSync(child, getSource, stack);
       if (child.type === "StringLiteral" || child.type === "StringTemplate") {
-        return evalRes[SelectorProxy.SourceOrExpr];
+        return evalRes[SourceOrExpr];
       }
-      if (SelectorProxy.Path in evalRes) {
+      if (Path in evalRes) {
         // a selector, so serialize to Val
         return JSON.stringify({
-          val: evalRes[SelectorProxy.SourceOrExpr],
-          valPath: evalRes[SelectorProxy.Path]
+          val: evalRes[SourceOrExpr],
+          valPath: evalRes[Path]
         });
       }
-      return JSON.stringify(evalRes[SelectorProxy.SourceOrExpr]);
+      return JSON.stringify(evalRes[SourceOrExpr]);
     }).join(""));
   }
   throw new EvalError("could not evaluate", expr);
@@ -442,12 +630,12 @@ function evaluate(expr, source, stack) {
 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,
+  Call: index$1.Call,
+  Expr: index$1.Expr,
+  NilSym: index$1.NilSym,
+  StringLiteral: index$1.StringLiteral,
+  StringTemplate: index$1.StringTemplate,
+  Sym: index$1.Sym,
   evaluate: evaluate
 });