@valbuild/core 0.16.0 → 0.17.0

package/dist/declarations/src/selector/future/primitive.d.ts

@@ -0,0 +1,9 @@
+import { Selector as UnknownSelector, GenericSelector, SelectorOf, SelectorSource } from "./index.js";
+import { Source, SourcePrimitive } from "../../source/index.js";
+import { Selector as BooleanSelector } from "./boolean.js";
+export type Selector<T extends SourcePrimitive> = GenericSelector<T> & {
+    eq(other: Source): BooleanSelector<boolean>;
+    andThen<U extends SelectorSource>(f: (v: UnknownSelector<NonNullable<T>>) => U): SelectorOf<U | NullableOf<T>>;
+};
+type NullableOf<T extends Source> = T extends null ? null : never;
+export {};

package/dist/declarations/src/selector/{remote.d.ts → future/remote.d.ts}

@@ -1,5 +1,5 @@
 import { Selector as UnknownSelector } from "./index.js";
-import { RemoteCompatibleSource } from "../source/remote.js";
+import { RemoteCompatibleSource } from "../../source/future/remote.js";
 declare const brand: unique symbol;
 export type RemoteSelector<T extends RemoteCompatibleSource> = UnknownSelector<T> & {
     readonly [brand]: "RemoteSelector";

package/dist/declarations/src/selector/future/string.d.ts

@@ -0,0 +1,2 @@
+import { Selector as PrimitiveSelector } from "./primitive.js";
+export type Selector<T extends string> = PrimitiveSelector<T>;

package/dist/declarations/src/selector/index.d.ts

@@ -1,4 +1,3 @@
-import { I18nSelector } from "./i18n.js";
 import { Selector as ObjectSelector } from "./object.js";
 import { UndistributedSourceArray as ArraySelector } from "./array.js";
 import { Selector as NumberSelector } from "./number.js";
@@ -9,38 +8,13 @@ import { FileSelector } from "./file.js";
 import { SourcePath } from "../val/index.js";
 import { Source, SourceArray, SourceObject, SourcePrimitive } from "../source/index.js";
 import { Schema } from "../schema/index.js";
-import { Expr } from "../expr/expr.js";
-import { RemoteSelector } from "./remote.js";
-import { A } from "ts-toolbelt";
-import { I18nSource, I18nCompatibleSource } from "../source/i18n.js";
-import { RemoteCompatibleSource, RemoteSource } from "../source/remote.js";
+import type { A } from "ts-toolbelt";
 import { FileSource } from "../source/file.js";
 import { RichText, RichTextSource } from "../source/richtext.js";
-/**
- * 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,
- * }));
- *
- */
-export type Selector<T extends Source> = Source extends T ? GenericSelector<T> : T extends I18nSource<infer L, infer S> ? I18nSelector<L, S> : T extends RemoteSource<infer S> ? S extends RemoteCompatibleSource ? RemoteSelector<S> : GenericSelector<Source, "Could not determine remote source"> : T extends FileSource ? FileSelector : T extends RichTextSource ? RichText : T extends SourceObject ? ObjectSelector<T> : T extends SourceArray ? ArraySelector<T> : T extends string ? StringSelector<T> : T extends number ? NumberSelector<T> : T extends boolean ? BooleanSelector<T> : T extends null ? PrimitiveSelector<null> : never;
+export type Selector<T extends Source> = Source extends T ? GenericSelector<T> : T extends FileSource ? FileSelector : T extends RichTextSource ? RichText : T extends SourceObject ? ObjectSelector<T> : T extends SourceArray ? ArraySelector<T> : T extends string ? StringSelector<T> : T extends number ? NumberSelector<T> : T extends boolean ? BooleanSelector<T> : T extends null ? PrimitiveSelector<null> : never;
 export type SelectorSource = SourcePrimitive | undefined | readonly SelectorSource[] | {
     [key: string]: SelectorSource;
-} | I18nSource<readonly string[], I18nCompatibleSource> | RemoteSource<RemoteCompatibleSource> | FileSource | RichTextSource | GenericSelector<Source>;
+} | FileSource | RichTextSource | GenericSelector<Source>;
 /**
  * @internal
  */
@@ -53,18 +27,17 @@ export declare const Path: unique symbol;
 /**
  * @internal
  */
-export declare const SourceOrExpr: unique symbol;
+export declare const GetSource: unique symbol;
 /**
  * @internal
  */
 export declare const ValError: unique symbol;
 export declare abstract class GenericSelector<out T extends Source, Error extends string | undefined = undefined> {
     readonly [Path]: SourcePath | undefined;
-    readonly [SourceOrExpr]: T | Expr;
+    readonly [GetSource]: T;
     readonly [ValError]: Error | undefined;
     readonly [GetSchema]: Schema<T> | undefined;
     constructor(valOrExpr: T, path: SourcePath | undefined, schema?: Schema<T>, error?: Error);
-    assert<U extends Source, E extends Source = null>(schema: Schema<U>, other?: () => E): SelectorOf<U | E>;
 }
 export type SourceOf<T extends SelectorSource> = Source extends T ? Source : T extends Source ? T : T extends undefined ? null : T extends GenericSelector<infer S> ? S : T extends readonly (infer S)[] ? S extends SelectorSource ? {
     [key in keyof T]: SourceOf<A.Try<T[key], SelectorSource>>;

package/dist/declarations/src/selector/object.d.ts

@@ -1,10 +1,3 @@
-import { Selector as UnknownSelector, GenericSelector, SelectorOf, SelectorSource } from "./index.js";
+import { GenericSelector } from "./index.js";
 import { SourceObject } from "../source/index.js";
-export type Selector<T extends SourceObject> = GenericSelector<T> & {
-    fold<Tag extends string>(key: Tag): <U extends SelectorSource>(cases: {
-        [key in T[Tag & keyof T] & string]: (v: UnknownSelector<T>) => U;
-    }) => SelectorOf<U>;
-    andThen<U extends SelectorSource>(f: (v: UnknownSelector<NonNullable<T>>) => U): SelectorOf<U>;
-} & {
-    readonly [key in keyof T]: UnknownSelector<T[key]>;
-};
+export type Selector<T extends SourceObject> = GenericSelector<T>;

package/dist/declarations/src/selector/primitive.d.ts

@@ -1,9 +1,3 @@
-import { Selector as UnknownSelector, GenericSelector, SelectorOf, SelectorSource } from "./index.js";
-import { Source, SourcePrimitive } from "../source/index.js";
-import { Selector as BooleanSelector } from "./boolean.js";
-export type Selector<T extends SourcePrimitive> = GenericSelector<T> & {
-    eq(other: Source): BooleanSelector<boolean>;
-    andThen<U extends SelectorSource>(f: (v: UnknownSelector<NonNullable<T>>) => U): SelectorOf<U | NullableOf<T>>;
-};
-type NullableOf<T extends Source> = T extends null ? null : never;
-export {};
+import { GenericSelector } from "./index.js";
+import { SourcePrimitive } from "../source/index.js";
+export type Selector<T extends SourcePrimitive> = GenericSelector<T>;

package/dist/declarations/src/source/{i18n.d.ts → future/i18n.d.ts}

@@ -1,6 +1,6 @@
 import { F } from "ts-toolbelt";
-import { SourcePrimitive, VAL_EXTENSION } from "./index.js";
-import { FileSource } from "./file.js";
+import { SourcePrimitive, VAL_EXTENSION } from "../index.js";
+import { FileSource } from "../file.js";
 /**
  * I18n sources cannot have nested remote sources.
  */

package/dist/declarations/src/source/{remote.d.ts → future/remote.d.ts}

@@ -1,7 +1,7 @@
-import { SourcePrimitive, VAL_EXTENSION, PhantomType } from "./index.js";
-import { FileSource } from "./file.js";
+import { SourcePrimitive, VAL_EXTENSION, PhantomType } from "../index.js";
+import { FileSource } from "../file.js";
 import { I18nCompatibleSource, I18nSource } from "./i18n.js";
-import { RichTextSource } from "./richtext.js";
+import { RichTextSource } from "../richtext.js";
 /**
  * Remote sources cannot include other remote sources.
  */

package/dist/declarations/src/source/index.d.ts

@@ -1,12 +1,13 @@
 import { FileSource } from "./file.js";
-import { I18nSource, I18nCompatibleSource } from "./i18n.js";
-import { RemoteSource, RemoteCompatibleSource } from "./remote.js";
+import { I18nSource, I18nCompatibleSource } from "./future/i18n.js";
+import { RemoteSource, RemoteCompatibleSource } from "./future/remote.js";
 import { RichTextSource } from "./richtext.js";
 export type Source = SourcePrimitive | SourceObject | SourceArray | I18nSource<string[], I18nCompatibleSource> | RemoteSource<RemoteCompatibleSource> | FileSource | RichTextSource;
 export type SourceObject = {
     [key in string]: Source;
 } & {
     fold?: never;
+    assert?: never;
     andThen?: never;
     _ref?: never;
     _type?: never;
@@ -16,7 +17,7 @@ export type SourceObject = {
 export type SourceArray = readonly Source[];
 export type SourcePrimitive = string | number | boolean | null;
 export declare const VAL_EXTENSION: "_type";
-export declare function getValExtension(source: Source): false | "" | 0 | "richtext" | "file" | "i18n" | "remote" | null | undefined;
+export declare function getValExtension(source: Source): false | "" | 0 | "richtext" | "remote" | "file" | "i18n" | null | undefined;
 /**
  * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
  *

package/dist/declarations/src/val/index.d.ts

@@ -4,8 +4,8 @@ import { Val as ArrayVal } from "./array.js";
 import { Val as PrimitiveVal } from "./primitive.js";
 import { Json, JsonArray, JsonObject, JsonPrimitive } from "../Json.js";
 import { Path, Selector } from "../selector/index.js";
-import { I18nSource } from "../source/i18n.js";
-import { RemoteSource } from "../source/remote.js";
+import { I18nSource } from "../source/future/i18n.js";
+import { RemoteSource } from "../source/future/remote.js";
 import { FileSource } from "../source/file.js";
 export type SerializedVal = {
     val: SerializedVal | Json;

package/dist/{SelectorProxy-63c2d0e2.esm.js → index-369caccf.esm.js}

@@ -218,21 +218,26 @@ function _createSuper(Derived) {
   };
 }
 
+// import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+
+// import { SerializedI18nSchema } from "./future/i18n";
+// import { SerializedOneOfSchema } from "./future/oneOf";
 var Schema = /*#__PURE__*/function () {
   function Schema() {
     _classCallCheck(this, Schema);
   }
   _createClass(Schema, [{
-    key: "remote",
-    value: function remote() {
-      // TODO: Schema<never, "Cannot create remote schema from non-remote source.">
-      throw new Error("You need Val Ultra to use .remote()");
-    }
+    key: "appendValidationError",
+    value:
+    // remote(): Src extends RemoteCompatibleSource
+    //   ? Schema<RemoteSource<Src>>
+    //   : never {
+    //   // TODO: Schema<never, "Cannot create remote schema from non-remote source.">
+    //   throw new Error("You need Val Ultra to use .remote()");
+    // }
 
     /** MUTATES! since internal and perf sensitive */
-  }, {
-    key: "appendValidationError",
-    value: function appendValidationError(current, path, message, value) {
+    function appendValidationError(current, path, message, value) {
       if (current) {
         if (current[path]) {
           current[path].push({
@@ -259,30 +264,6 @@ var Schema = /*#__PURE__*/function () {
 
 // TODO: SourceError<"Could not determine type of Schema">
 
-/* 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
  */
@@ -295,27 +276,18 @@ var Path = Symbol("Path");
 /**
  * @internal
  */
-var SourceOrExpr = Symbol("SourceOrExpr");
+var GetSource = Symbol("GetSource");
 /**
  * @internal
  */
 var ValError = Symbol("ValError");
-var GenericSelector = /*#__PURE__*/function () {
-  function GenericSelector(valOrExpr, path, schema, error) {
-    _classCallCheck(this, GenericSelector);
-    this[Path] = path;
-    this[SourceOrExpr] = valOrExpr;
-    this[ValError] = error;
-    this[GetSchema] = schema;
-  }
-  _createClass(GenericSelector, [{
-    key: "assert",
-    value: function assert(schema, other) {
-      throw new Error("Not implemented");
-    }
-  }]);
-  return GenericSelector;
-}();
+var GenericSelector = /*#__PURE__*/_createClass(function GenericSelector(valOrExpr, path, schema, error) {
+  _classCallCheck(this, GenericSelector);
+  this[Path] = path;
+  this[GetSource] = valOrExpr;
+  this[ValError] = error;
+  this[GetSchema] = schema;
+});
 
 /**
  * Use this type to convert types that accepts both Source and Selectors
@@ -534,7 +506,7 @@ var ImageSchema = /*#__PURE__*/function (_Schema) {
 var image = function image(options) {
   return new ImageSchema(options);
 };
-var convertImageSource = function convertImageSource(src) {
+var convertFileSource = function convertFileSource(src) {
   var _src$metadata;
   // TODO: /public should be configurable
   return {
@@ -575,148 +547,4 @@ function getValPath(valOrSelector) {
   return valOrSelector[Path];
 }
 
-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 _typeof(source) === "object" && source !== null && (SourceOrExpr in source || Path in source);
-}
-function newSelectorProxy(source, path, moduleSchema) {
-  var _ref;
-  if (_typeof(source) === "object") {
-    if (isSelector(source)) {
-      return source;
-    } else if (isSerializedVal(source)) {
-      return newSelectorProxy(source.val, source.valPath);
-    }
-  }
-  if (source && source[FILE_REF_PROP] && source[VAL_EXTENSION] === "file") {
-    var fileRef = source[FILE_REF_PROP];
-    if (typeof fileRef !== "string") {
-      throw Error("Invalid file ref: " + fileRef);
-    }
-    return newSelectorProxy(convertImageSource(source), path, moduleSchema);
-  }
-  switch (_typeof(source)) {
-    case "function":
-    case "symbol":
-      throw Error("Invalid selector type: ".concat(_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 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 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);
-        }
-      }, _defineProperty(_ref, SourceOrExpr, source === undefined ? null : source), _defineProperty(_ref, Path, path), _defineProperty(_ref, GetSchema, moduleSchema), _ref;
-  }
-}
-function createValPathOfItem(arrayPath, prop) {
-  if (_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 (_typeof(valueOrSelector) === "object" && (SourceOrExpr in valueOrSelector || Path in valueOrSelector)) {
-    var selectorValue = valueOrSelector[SourceOrExpr];
-    return selectorValue;
-  }
-  return valueOrSelector;
-}
-
-export { Call as C, Expr as E, FILE_REF_PROP as F, GenericSelector as G, ImageSchema as I, NilSym as N, Path as P, Schema as S, VAL_EXTENSION as V, _inherits as _, _createSuper as a, _classCallCheck as b, _createClass as c, _objectSpread2 as d, _defineProperty as e, _typeof as f, getValPath as g, file as h, image as i, _slicedToArray as j, isFile as k, createValPathOfItem as l, SourceOrExpr as m, newSelectorProxy as n, isSelector as o, isSerializedVal as p, convertImageSource as q, getSchema as r, isVal as s, Sym as t, StringLiteral as u, StringTemplate as v, _toConsumableArray as w };
+export { Call as C, Expr as E, FILE_REF_PROP as F, GetSource as G, ImageSchema as I, NilSym as N, Path as P, Schema as S, VAL_EXTENSION as V, _inherits as _, _createSuper as a, _classCallCheck as b, _createClass as c, _defineProperty as d, _typeof as e, _objectSpread2 as f, getValPath as g, file as h, image as i, _slicedToArray as j, isFile as k, isSerializedVal as l, convertFileSource as m, getSchema as n, isVal as o, GenericSelector as p, Sym as q, StringLiteral as r, StringTemplate as s, _toConsumableArray as t, GetSchema as u };

package/dist/{index-af761363.esm.js → index-3e3e839e.esm.js}

@@ -1,4 +1,4 @@
-import { d as _objectSpread2, j as _slicedToArray, c as _createClass, b as _classCallCheck, t as Sym, C as Call, u as StringLiteral, v as StringTemplate, n as newSelectorProxy, m as SourceOrExpr, P as Path, p as isSerializedVal, f as _typeof, w as _toConsumableArray, E as Expr, N as NilSym } from './SelectorProxy-63c2d0e2.esm.js';
+import { f as _objectSpread2, j as _slicedToArray, c as _createClass, b as _classCallCheck, q as Sym, C as Call, r as StringLiteral, s as StringTemplate, e as _typeof, l as isSerializedVal, F as FILE_REF_PROP, V as VAL_EXTENSION, m as convertFileSource, d as _defineProperty, S as Schema, E as Expr, t as _toConsumableArray, N as NilSym } from './index-369caccf.esm.js';
 import { i as isErr, e as err, o as ok, a as isOk } from './result-b96df128.esm.js';
 
 var WHITE_SPACE = ["\n", "\r", "\t", " "];
@@ -260,6 +260,194 @@ function parse(input) {
   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 _typeof(source) === "object" && source !== null && (SourceOrExpr in source || Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (_typeof(source) === "object") {
+    if (isSelector(source)) {
+      return source;
+    } else if (isSerializedVal(source)) {
+      return newSelectorProxy(source.val, source.valPath);
+    }
+  }
+  if (source && source[FILE_REF_PROP] && source[VAL_EXTENSION] === "file") {
+    var fileRef = source[FILE_REF_PROP];
+    if (typeof fileRef !== "string") {
+      throw Error("Invalid file ref: " + fileRef);
+    }
+    return newSelectorProxy(convertFileSource(source), path, moduleSchema);
+  }
+  switch (_typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(_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 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 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);
+        }
+      }, _defineProperty(_ref, SourceOrExpr, source === undefined ? null : source), _defineProperty(_ref, Path, path), _defineProperty(_ref, GetSchema, moduleSchema), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (_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 (_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) {
     _classCallCheck(this, EvalError);