@valbuild/core 0.16.0 → 0.17.0

package/dist/{ops-74661336.esm.js → ops-23a5abb2.esm.js}

@@ -1,6 +1,150 @@
-import { _ as _inherits, a as _createSuper, b as _classCallCheck, c as _createClass, f as _typeof, e as _defineProperty, j as _slicedToArray, l as createValPathOfItem, d as _objectSpread2, S as Schema, V as VAL_EXTENSION, n as newSelectorProxy, m as SourceOrExpr, E as Expr, w as _toConsumableArray, I as ImageSchema } from './SelectorProxy-63c2d0e2.esm.js';
+import { e as _typeof, l as isSerializedVal, F as FILE_REF_PROP, V as VAL_EXTENSION, m as convertFileSource, d as _defineProperty, G as GetSource, P as Path, u as GetSchema, S as Schema, E as Expr, _ as _inherits, a as _createSuper, b as _classCallCheck, c as _createClass, j as _slicedToArray, f as _objectSpread2, t as _toConsumableArray, I as ImageSchema } from './index-369caccf.esm.js';
 import { _ as _createForOfIteratorHelper } from './result-b96df128.esm.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 _typeof(source) === "object" && source !== null && (GetSource 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 === GetSource) {
+              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 === GetSource) {
+              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[GetSource];
+            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, GetSource, 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" && (GetSource in valueOrSelector || Path in valueOrSelector)) {
+    var selectorValue = valueOrSelector[GetSource];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}
+
 var ObjectSchema = /*#__PURE__*/function (_Schema) {
   _inherits(ObjectSchema, _Schema);
   var _super = _createSuper(ObjectSchema);
@@ -183,53 +327,6 @@ var array = function array(schema) {
   return new ArraySchema(schema);
 };
 
-var I18nSchema = /*#__PURE__*/function (_Schema) {
-  _inherits(I18nSchema, _Schema);
-  var _super = _createSuper(I18nSchema);
-  function I18nSchema(locales, item) {
-    var _this;
-    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    _classCallCheck(this, I18nSchema);
-    _this = _super.call(this);
-    _this.locales = locales;
-    _this.item = item;
-    _this.opt = opt;
-    return _this;
-  }
-  _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;
-}(Schema);
-var i18n = function i18n(locales) {
-  return function (schema) {
-    return new I18nSchema(locales, schema);
-  };
-};
-
 var UnionSchema = /*#__PURE__*/function (_Schema) {
   _inherits(UnionSchema, _Schema);
   var _super = _createSuper(UnionSchema);
@@ -361,10 +458,11 @@ id,
 schema,
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 source) {
-  return newSelectorProxy(source, id, schema);
+  var _ref;
+  return _ref = {}, _defineProperty(_ref, GetSource, source), _defineProperty(_ref, GetSchema, schema), _defineProperty(_ref, Path, id), _ref;
 }
-function getRawSource(valModule) {
-  var sourceOrExpr = valModule[SourceOrExpr];
+function getSource(valModule) {
+  var sourceOrExpr = valModule[GetSource];
   if (sourceOrExpr instanceof Expr) {
     throw Error("Cannot get raw source of an Expr");
   }
@@ -380,9 +478,16 @@ function isObjectSchema(schema) {
 function isArraySchema(schema) {
   return schema instanceof ArraySchema || _typeof(schema) === "object" && "type" in schema && schema.type === "array";
 }
-function isI18nSchema(schema) {
-  return schema instanceof I18nSchema || _typeof(schema) === "object" && "type" in schema && schema.type === "i18n";
-}
+
+// 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 || _typeof(schema) === "object" && "type" in schema && schema.type === "union";
 }
@@ -394,6 +499,16 @@ function isRichTextSchema(schema) {
 function isImageSchema(schema) {
   return schema instanceof ImageSchema || _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 = _toConsumableArray(parts);
@@ -427,15 +542,23 @@ function resolvePath(path, valModule, schema) {
       }
       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: {
@@ -487,7 +610,14 @@ function resolvePath(path, valModule, schema) {
     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
   };
@@ -538,4 +668,4 @@ var PatchError = /*#__PURE__*/_createClass(function PatchError(message) {
  * NOTE: MAY mutate the input document.
  */
 
-export { PatchError as P, array as a, resolvePath as b, content as c, getRawSource as g, i18n as i, object as o, richtext as r, splitModuleIdAndModulePath as s, union as u };
+export { PatchError as P, array as a, createValPathOfItem as b, content as c, resolvePath as d, getSource as g, isSelector as i, newSelectorProxy as n, object as o, richtext as r, splitModuleIdAndModulePath as s, union as u };