@valbuild/core 0.16.0 → 0.17.0

package/dist/{ops-1b6e0e35.cjs.prod.js → ops-0d09f8ee.cjs.prod.js}

@@ -1,21 +1,165 @@
 'use strict';
 
-var SelectorProxy = require('./SelectorProxy-2af1b2b8.cjs.prod.js');
+var index = require('./index-8706c87e.cjs.prod.js');
 var result = require('./result-26f67b40.cjs.prod.js');
 
+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._typeof(source) === "object" && source !== null && (index.GetSource in source || index.Path in source);
+}
+function newSelectorProxy(source, path, moduleSchema) {
+  var _ref;
+  if (index._typeof(source) === "object") {
+    if (isSelector(source)) {
+      return source;
+    } else if (index.isSerializedVal(source)) {
+      return newSelectorProxy(source.val, source.valPath);
+    }
+  }
+  if (source && source[index.FILE_REF_PROP] && source[index.VAL_EXTENSION] === "file") {
+    var fileRef = source[index.FILE_REF_PROP];
+    if (typeof fileRef !== "string") {
+      throw Error("Invalid file ref: " + fileRef);
+    }
+    return newSelectorProxy(index.convertFileSource(source), path, moduleSchema);
+  }
+  switch (index._typeof(source)) {
+    case "function":
+    case "symbol":
+      throw Error("Invalid selector type: ".concat(index._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 === index.GetSource) {
+              return true;
+            }
+            if (prop === index.Path) {
+              return true;
+            }
+            if (prop === "andThen") {
+              return true;
+            }
+            if (prop === index.GetSchema) {
+              return true;
+            }
+            return prop in target;
+          },
+          get: function get(target, prop) {
+            if (prop === index.GetSource) {
+              return source;
+            }
+            if (prop === index.Path) {
+              return path;
+            }
+            if (prop === index.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.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[index.GetSource];
+            if (otherValue instanceof index.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._defineProperty(_ref, index.GetSource, source === undefined ? null : source), index._defineProperty(_ref, index.Path, path), index._defineProperty(_ref, index.GetSchema, moduleSchema), _ref;
+  }
+}
+function createValPathOfItem(arrayPath, prop) {
+  if (index._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._typeof(valueOrSelector) === "object" && (index.GetSource in valueOrSelector || index.Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[index.GetSource];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
 var ObjectSchema = /*#__PURE__*/function (_Schema) {
-  SelectorProxy._inherits(ObjectSchema, _Schema);
-  var _super = SelectorProxy._createSuper(ObjectSchema);
+  index._inherits(ObjectSchema, _Schema);
+  var _super = index._createSuper(ObjectSchema);
   function ObjectSchema(items) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    SelectorProxy._classCallCheck(this, ObjectSchema);
+    index._classCallCheck(this, ObjectSchema);
     _this = _super.call(this);
     _this.items = items;
     _this.opt = opt;
     return _this;
   }
-  SelectorProxy._createClass(ObjectSchema, [{
+  index._createClass(ObjectSchema, [{
     key: "validate",
     value: function validate(path, src) {
       var _this2 = this;
@@ -23,20 +167,20 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
-      if (SelectorProxy._typeof(src) !== "object") {
-        return SelectorProxy._defineProperty({}, path, [{
-          message: "Expected 'object', got '".concat(SelectorProxy._typeof(src), "'")
+      if (index._typeof(src) !== "object") {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'object', got '".concat(index._typeof(src), "'")
         }]);
       } else if (Array.isArray(src)) {
-        return SelectorProxy._defineProperty({}, path, [{
+        return index._defineProperty({}, path, [{
           message: "Expected 'object', got 'array'"
         }]);
       }
       Object.entries(this.items).forEach(function (_ref3) {
-        var _ref4 = SelectorProxy._slicedToArray(_ref3, 2),
+        var _ref4 = index._slicedToArray(_ref3, 2),
           key = _ref4[0],
           schema = _ref4[1];
-        var subPath = SelectorProxy.createValPathOfItem(path, key);
+        var subPath = createValPathOfItem(path, key);
         if (!subPath) {
           error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at key ").concat(key),
           // Should! never happen
@@ -44,7 +188,7 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
         } else {
           var subError = schema.validate(subPath, src[key]);
           if (subError && error) {
-            error = SelectorProxy._objectSpread2(SelectorProxy._objectSpread2({}, subError), error);
+            error = index._objectSpread2(index._objectSpread2({}, subError), error);
           } else if (subError) {
             error = subError;
           }
@@ -62,14 +206,14 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
         return false;
       }
       for (var _i = 0, _Object$entries = Object.entries(this.items); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = SelectorProxy._slicedToArray(_Object$entries[_i], 2),
+        var _Object$entries$_i = index._slicedToArray(_Object$entries[_i], 2),
           _key = _Object$entries$_i[0],
           schema = _Object$entries$_i[1];
         if (!schema.assert(src[_key])) {
           return false;
         }
       }
-      return SelectorProxy._typeof(src) === "object" && !Array.isArray(src);
+      return index._typeof(src) === "object" && !Array.isArray(src);
     }
   }, {
     key: "optional",
@@ -82,7 +226,7 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
       return {
         type: "object",
         items: Object.fromEntries(Object.entries(this.items).map(function (_ref5) {
-          var _ref6 = SelectorProxy._slicedToArray(_ref5, 2),
+          var _ref6 = index._slicedToArray(_ref5, 2),
             key = _ref6[0],
             schema = _ref6[1];
           return [key, schema.serialize()];
@@ -92,24 +236,24 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     }
   }]);
   return ObjectSchema;
-}(SelectorProxy.Schema);
+}(index.Schema);
 var object = function object(schema) {
   return new ObjectSchema(schema);
 };
 
 var ArraySchema = /*#__PURE__*/function (_Schema) {
-  SelectorProxy._inherits(ArraySchema, _Schema);
-  var _super = SelectorProxy._createSuper(ArraySchema);
+  index._inherits(ArraySchema, _Schema);
+  var _super = index._createSuper(ArraySchema);
   function ArraySchema(item) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    SelectorProxy._classCallCheck(this, ArraySchema);
+    index._classCallCheck(this, ArraySchema);
     _this = _super.call(this);
     _this.item = item;
     _this.opt = opt;
     return _this;
   }
-  SelectorProxy._createClass(ArraySchema, [{
+  index._createClass(ArraySchema, [{
     key: "validate",
     value: function validate(path, src) {
       var _this2 = this;
@@ -117,13 +261,13 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
-      if (SelectorProxy._typeof(src) !== "object" || !Array.isArray(src)) {
-        return SelectorProxy._defineProperty({}, path, [{
-          message: "Expected 'array', got '".concat(SelectorProxy._typeof(src), "'")
+      if (index._typeof(src) !== "object" || !Array.isArray(src)) {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'array', got '".concat(index._typeof(src), "'")
         }]);
       }
       src.forEach(function (i, idx) {
-        var subPath = SelectorProxy.createValPathOfItem(path, idx);
+        var subPath = createValPathOfItem(path, idx);
         if (!subPath) {
           error = _this2.appendValidationError(error, path, "Internal error: could not create path at ".concat(!path && typeof path === "string" ? "<empty string>" : path, " at index ").concat(idx),
           // Should! never happen
@@ -131,7 +275,7 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
         } else {
           var subError = _this2.item.validate(subPath, i);
           if (subError && error) {
-            error = SelectorProxy._objectSpread2(SelectorProxy._objectSpread2({}, subError), error);
+            error = index._objectSpread2(index._objectSpread2({}, subError), error);
           } else if (subError) {
             error = subError;
           }
@@ -162,7 +306,7 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
       } finally {
         _iterator.f();
       }
-      return SelectorProxy._typeof(src) === "object" && Array.isArray(src);
+      return index._typeof(src) === "object" && Array.isArray(src);
     }
   }, {
     key: "optional",
@@ -180,72 +324,25 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
     }
   }]);
   return ArraySchema;
-}(SelectorProxy.Schema);
+}(index.Schema);
 var array = function array(schema) {
   return new ArraySchema(schema);
 };
 
-var I18nSchema = /*#__PURE__*/function (_Schema) {
-  SelectorProxy._inherits(I18nSchema, _Schema);
-  var _super = SelectorProxy._createSuper(I18nSchema);
-  function I18nSchema(locales, item) {
-    var _this;
-    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    SelectorProxy._classCallCheck(this, I18nSchema);
-    _this = _super.call(this);
-    _this.locales = locales;
-    _this.item = item;
-    _this.opt = opt;
-    return _this;
-  }
-  SelectorProxy._createClass(I18nSchema, [{
-    key: "validate",
-    value: function validate(path, src) {
-      throw new Error("Method not implemented.");
-    }
-  }, {
-    key: "assert",
-    value: function assert(src) {
-      throw new Error("Method not implemented.");
-    }
-  }, {
-    key: "optional",
-    value: function optional() {
-      return new I18nSchema(this.locales, this.item, true);
-    }
-  }, {
-    key: "serialize",
-    value: function serialize() {
-      return {
-        type: "i18n",
-        item: this.item.serialize(),
-        locales: this.locales,
-        opt: this.opt
-      };
-    }
-  }]);
-  return I18nSchema;
-}(SelectorProxy.Schema);
-var i18n = function i18n(locales) {
-  return function (schema) {
-    return new I18nSchema(locales, schema);
-  };
-};
-
 var UnionSchema = /*#__PURE__*/function (_Schema) {
-  SelectorProxy._inherits(UnionSchema, _Schema);
-  var _super = SelectorProxy._createSuper(UnionSchema);
+  index._inherits(UnionSchema, _Schema);
+  var _super = index._createSuper(UnionSchema);
   function UnionSchema(key, items) {
     var _this;
     var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    SelectorProxy._classCallCheck(this, UnionSchema);
+    index._classCallCheck(this, UnionSchema);
     _this = _super.call(this);
     _this.key = key;
     _this.items = items;
     _this.opt = opt;
     return _this;
   }
-  SelectorProxy._createClass(UnionSchema, [{
+  index._createClass(UnionSchema, [{
     key: "validate",
     value: function validate(path, src) {
       throw new Error("Method not implemented.");
@@ -274,7 +371,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
     }
   }]);
   return UnionSchema;
-}(SelectorProxy.Schema);
+}(index.Schema);
 var union = function union(key) {
   for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     objects[_key - 1] = arguments[_key];
@@ -283,47 +380,47 @@ var union = function union(key) {
 };
 
 var RichTextSchema = /*#__PURE__*/function (_Schema) {
-  SelectorProxy._inherits(RichTextSchema, _Schema);
-  var _super = SelectorProxy._createSuper(RichTextSchema);
+  index._inherits(RichTextSchema, _Schema);
+  var _super = index._createSuper(RichTextSchema);
   function RichTextSchema() {
     var _this;
     var opt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    SelectorProxy._classCallCheck(this, RichTextSchema);
+    index._classCallCheck(this, RichTextSchema);
     _this = _super.call(this);
     _this.opt = opt;
     return _this;
   }
-  SelectorProxy._createClass(RichTextSchema, [{
+  index._createClass(RichTextSchema, [{
     key: "validate",
     value: function validate(path, src) {
       if (this.opt && (src === null || src === undefined)) {
         return false;
       }
       if (src === null || src === undefined) {
-        return SelectorProxy._defineProperty({}, path, [{
+        return index._defineProperty({}, path, [{
           message: "Expected non-nullable got '".concat(src, "'")
         }]);
       }
-      if (SelectorProxy._typeof(src) !== "object" && !Array.isArray(src)) {
-        return SelectorProxy._defineProperty({}, path, [{
-          message: "Expected 'object' (that is not of an array) or 'string', got '".concat(SelectorProxy._typeof(src), "'"),
+      if (index._typeof(src) !== "object" && !Array.isArray(src)) {
+        return index._defineProperty({}, path, [{
+          message: "Expected 'object' (that is not of an array) or 'string', got '".concat(index._typeof(src), "'"),
           value: src
         }]);
       }
-      if (src[SelectorProxy.VAL_EXTENSION] !== "richtext") {
-        return SelectorProxy._defineProperty({}, path, [{
-          message: "Expected _type key with value 'richtext' got '".concat(src[SelectorProxy.VAL_EXTENSION], "'"),
+      if (src[index.VAL_EXTENSION] !== "richtext") {
+        return index._defineProperty({}, path, [{
+          message: "Expected _type key with value 'richtext' got '".concat(src[index.VAL_EXTENSION], "'"),
           value: src
         }]);
       }
       if (src.type !== "root") {
-        return SelectorProxy._defineProperty({}, path, [{
+        return index._defineProperty({}, path, [{
           message: "Expected type key with value 'root' got '".concat(src.type, "'"),
           value: src
         }]);
       }
-      if (SelectorProxy._typeof(src.children) !== "object" && !Array.isArray(src.children)) {
-        return SelectorProxy._defineProperty({}, path, [{
+      if (index._typeof(src.children) !== "object" && !Array.isArray(src.children)) {
+        return index._defineProperty({}, path, [{
           message: "Expected children to be an array, but got '".concat(src.type, "'"),
           value: src
         }]);
@@ -351,7 +448,7 @@ var RichTextSchema = /*#__PURE__*/function (_Schema) {
     }
   }]);
   return RichTextSchema;
-}(SelectorProxy.Schema);
+}(index.Schema);
 var richtext = function richtext() {
   return new RichTextSchema();
 };
@@ -363,11 +460,12 @@ id,
 schema,
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 source) {
-  return SelectorProxy.newSelectorProxy(source, id, schema);
+  var _ref;
+  return _ref = {}, index._defineProperty(_ref, index.GetSource, source), index._defineProperty(_ref, index.GetSchema, schema), index._defineProperty(_ref, index.Path, id), _ref;
 }
-function getRawSource(valModule) {
-  var sourceOrExpr = valModule[SelectorProxy.SourceOrExpr];
-  if (sourceOrExpr instanceof SelectorProxy.Expr) {
+function getSource(valModule) {
+  var sourceOrExpr = valModule[index.GetSource];
+  if (sourceOrExpr instanceof index.Expr) {
     throw Error("Cannot get raw source of an Expr");
   }
   var source = sourceOrExpr;
@@ -377,28 +475,45 @@ function splitModuleIdAndModulePath(path) {
   return [path.slice(0, path.indexOf(".")), path.slice(path.indexOf(".") + 1)];
 }
 function isObjectSchema(schema) {
-  return schema instanceof ObjectSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "object";
+  return schema instanceof ObjectSchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "object";
 }
 function isArraySchema(schema) {
-  return schema instanceof ArraySchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "array";
-}
-function isI18nSchema(schema) {
-  return schema instanceof I18nSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "i18n";
+  return schema instanceof ArraySchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "array";
 }
+
+// function isI18nSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is I18nSchema<readonly string[]> | SerializedI18nSchema {
+//   return (
+//     schema instanceof I18nSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "i18n")
+//   );
+// }
+
 function isUnionSchema(schema) {
-  return schema instanceof UnionSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "union";
+  return schema instanceof UnionSchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "union";
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function isRichTextSchema(schema) {
-  return schema instanceof RichTextSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
+  return schema instanceof RichTextSchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "richtext";
 }
 function isImageSchema(schema) {
-  return schema instanceof SelectorProxy.ImageSchema || SelectorProxy._typeof(schema) === "object" && "type" in schema && schema.type === "image";
+  return schema instanceof index.ImageSchema || index._typeof(schema) === "object" && "type" in schema && schema.type === "image";
 }
+
+// function isOneOfSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is OneOfSchema<GenericSelector<SourceArray>> | SerializedOneOfSchema {
+//   return (
+//     schema instanceof OneOfSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "oneOf")
+//   );
+// }
+
 function resolvePath(path, valModule, schema) {
   var parts = parsePath(path);
-  var origParts = SelectorProxy._toConsumableArray(parts);
+  var origParts = index._toConsumableArray(parts);
   var resolvedSchema = schema;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   var resolvedSource = valModule;
@@ -411,8 +526,8 @@ function resolvePath(path, valModule, schema) {
       if (Number.isNaN(Number(part))) {
         throw Error("Invalid path: array schema ".concat(resolvedSchema, " must have ").concat(part, " a number as path"));
       }
-      if (SelectorProxy._typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
-        throw Error("Schema type error: expected source to be type of array, but got ".concat(SelectorProxy._typeof(resolvedSource)));
+      if (index._typeof(resolvedSource) !== "object" && !Array.isArray(resolvedSource)) {
+        throw Error("Schema type error: expected source to be type of array, but got ".concat(index._typeof(resolvedSource)));
       }
       if (!resolvedSource[part]) {
         var _resolvedSource;
@@ -421,23 +536,31 @@ function resolvePath(path, valModule, schema) {
       resolvedSource = resolvedSource[part];
       resolvedSchema = resolvedSchema.item;
     } else if (isObjectSchema(resolvedSchema)) {
-      if (SelectorProxy._typeof(resolvedSource) !== "object") {
-        throw Error("Schema type error: expected source to be type of object, but got ".concat(SelectorProxy._typeof(resolvedSource)));
+      if (index._typeof(resolvedSource) !== "object") {
+        throw Error("Schema type error: expected source to be type of object, but got ".concat(index._typeof(resolvedSource)));
       }
       if (!resolvedSource[part]) {
         throw Error("Invalid path: object source did not have key ".concat(part, " from path: ").concat(path));
       }
       resolvedSource = resolvedSource[part];
       resolvedSchema = resolvedSchema.items[part];
-    } else if (isI18nSchema(resolvedSchema)) {
-      if (!resolvedSchema.locales.includes(part)) {
-        throw Error("Invalid path: i18n schema ".concat(resolvedSchema, " supports locales ").concat(resolvedSchema.locales.join(", "), ", but found: ").concat(part));
-      }
-      if (!Object.keys(resolvedSource).includes(part)) {
-        throw Error("Schema type error: expected source to be type of i18n with locale ".concat(part, ", but got ").concat(JSON.stringify(Object.keys(resolvedSource))));
-      }
-      resolvedSource = resolvedSource[part];
-      resolvedSchema = resolvedSchema.item;
+      // } else if (isI18nSchema(resolvedSchema)) {
+      //   if (!resolvedSchema.locales.includes(part)) {
+      //     throw Error(
+      //       `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+      //         ", "
+      //       )}, but found: ${part}`
+      //     );
+      //   }
+      //   if (!Object.keys(resolvedSource).includes(part)) {
+      //     throw Error(
+      //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
+      //         Object.keys(resolvedSource)
+      //       )}`
+      //     );
+      //   }
+      //   resolvedSource = resolvedSource[part];
+      //   resolvedSchema = resolvedSchema.item;
     } else if (isImageSchema(resolvedSchema)) {
       return {
         v: {
@@ -483,13 +606,20 @@ function resolvePath(path, valModule, schema) {
   };
   while (parts.length > 0) {
     var _ret = _loop();
-    if (SelectorProxy._typeof(_ret) === "object") return _ret.v;
+    if (index._typeof(_ret) === "object") return _ret.v;
   }
   if (parts.length > 0) {
     throw Error("Invalid path: ".concat(parts.join("."), " is not a valid path"));
   }
   return {
-    path: path,
+    path: origParts.map(function (p) {
+      if (!Number.isNaN(Number(p))) {
+        return p;
+      } else {
+        return JSON.stringify(p);
+      }
+    }).join("."),
+    // TODO: create a function generate path from parts (not sure if this always works)
     schema: resolvedSchema,
     source: resolvedSource
   };
@@ -531,8 +661,8 @@ function parsePath(input) {
   return result;
 }
 
-var PatchError = /*#__PURE__*/SelectorProxy._createClass(function PatchError(message) {
-  SelectorProxy._classCallCheck(this, PatchError);
+var PatchError = /*#__PURE__*/index._createClass(function PatchError(message) {
+  index._classCallCheck(this, PatchError);
   this.message = message;
 });
 
@@ -543,8 +673,10 @@ var PatchError = /*#__PURE__*/SelectorProxy._createClass(function PatchError(mes
 exports.PatchError = PatchError;
 exports.array = array;
 exports.content = content;
-exports.getRawSource = getRawSource;
-exports.i18n = i18n;
+exports.createValPathOfItem = createValPathOfItem;
+exports.getSource = getSource;
+exports.isSelector = isSelector;
+exports.newSelectorProxy = newSelectorProxy;
 exports.object = object;
 exports.resolvePath = resolvePath;
 exports.richtext = richtext;