@remoteoss/json-schema-form 0.2.0-beta.0 → 0.4.0-beta.0

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.2.0-beta.0
- Generated: Tue, 20 Jun 2023 08:31:44 GMT
+ NPM Package: @remoteoss/json-schema-form@0.4.0-beta.0
+ Generated: Thu, 22 Jun 2023 10:03:23 GMT
 
  MIT License
 
@@ -3496,6 +3496,440 @@ var require_set = __commonJS({
   }
 });
 
+// node_modules/synchronous-promise/index.js
+var require_synchronous_promise = __commonJS({
+  "node_modules/synchronous-promise/index.js"(exports2, module2) {
+    "use strict";
+    function makeArrayFrom(obj) {
+      return Array.prototype.slice.apply(obj);
+    }
+    var PENDING = "pending";
+    var RESOLVED = "resolved";
+    var REJECTED = "rejected";
+    function SynchronousPromise4(handler) {
+      this.status = PENDING;
+      this._continuations = [];
+      this._parent = null;
+      this._paused = false;
+      if (handler) {
+        handler.call(
+          this,
+          this._continueWith.bind(this),
+          this._failWith.bind(this)
+        );
+      }
+    }
+    function looksLikeAPromise(obj) {
+      return obj && typeof obj.then === "function";
+    }
+    function passThrough(value) {
+      return value;
+    }
+    SynchronousPromise4.prototype = {
+      then: function(nextFn, catchFn) {
+        var next = SynchronousPromise4.unresolved()._setParent(this);
+        if (this._isRejected()) {
+          if (this._paused) {
+            this._continuations.push({
+              promise: next,
+              nextFn,
+              catchFn
+            });
+            return next;
+          }
+          if (catchFn) {
+            try {
+              var catchResult = catchFn(this._error);
+              if (looksLikeAPromise(catchResult)) {
+                this._chainPromiseData(catchResult, next);
+                return next;
+              } else {
+                return SynchronousPromise4.resolve(catchResult)._setParent(this);
+              }
+            } catch (e) {
+              return SynchronousPromise4.reject(e)._setParent(this);
+            }
+          }
+          return SynchronousPromise4.reject(this._error)._setParent(this);
+        }
+        this._continuations.push({
+          promise: next,
+          nextFn,
+          catchFn
+        });
+        this._runResolutions();
+        return next;
+      },
+      catch: function(handler) {
+        if (this._isResolved()) {
+          return SynchronousPromise4.resolve(this._data)._setParent(this);
+        }
+        var next = SynchronousPromise4.unresolved()._setParent(this);
+        this._continuations.push({
+          promise: next,
+          catchFn: handler
+        });
+        this._runRejections();
+        return next;
+      },
+      finally: function(callback) {
+        var ran = false;
+        function runFinally(result, err) {
+          if (!ran) {
+            ran = true;
+            if (!callback) {
+              callback = passThrough;
+            }
+            var callbackResult = callback(result);
+            if (looksLikeAPromise(callbackResult)) {
+              return callbackResult.then(function() {
+                if (err) {
+                  throw err;
+                }
+                return result;
+              });
+            } else {
+              return result;
+            }
+          }
+        }
+        return this.then(function(result) {
+          return runFinally(result);
+        }).catch(function(err) {
+          return runFinally(null, err);
+        });
+      },
+      pause: function() {
+        this._paused = true;
+        return this;
+      },
+      resume: function() {
+        var firstPaused = this._findFirstPaused();
+        if (firstPaused) {
+          firstPaused._paused = false;
+          firstPaused._runResolutions();
+          firstPaused._runRejections();
+        }
+        return this;
+      },
+      _findAncestry: function() {
+        return this._continuations.reduce(function(acc, cur) {
+          if (cur.promise) {
+            var node = {
+              promise: cur.promise,
+              children: cur.promise._findAncestry()
+            };
+            acc.push(node);
+          }
+          return acc;
+        }, []);
+      },
+      _setParent: function(parent) {
+        if (this._parent) {
+          throw new Error("parent already set");
+        }
+        this._parent = parent;
+        return this;
+      },
+      _continueWith: function(data) {
+        var firstPending = this._findFirstPending();
+        if (firstPending) {
+          firstPending._data = data;
+          firstPending._setResolved();
+        }
+      },
+      _findFirstPending: function() {
+        return this._findFirstAncestor(function(test2) {
+          return test2._isPending && test2._isPending();
+        });
+      },
+      _findFirstPaused: function() {
+        return this._findFirstAncestor(function(test2) {
+          return test2._paused;
+        });
+      },
+      _findFirstAncestor: function(matching) {
+        var test2 = this;
+        var result;
+        while (test2) {
+          if (matching(test2)) {
+            result = test2;
+          }
+          test2 = test2._parent;
+        }
+        return result;
+      },
+      _failWith: function(error) {
+        var firstRejected = this._findFirstPending();
+        if (firstRejected) {
+          firstRejected._error = error;
+          firstRejected._setRejected();
+        }
+      },
+      _takeContinuations: function() {
+        return this._continuations.splice(0, this._continuations.length);
+      },
+      _runRejections: function() {
+        if (this._paused || !this._isRejected()) {
+          return;
+        }
+        var error = this._error, continuations = this._takeContinuations(), self2 = this;
+        continuations.forEach(function(cont) {
+          if (cont.catchFn) {
+            try {
+              var catchResult = cont.catchFn(error);
+              self2._handleUserFunctionResult(catchResult, cont.promise);
+            } catch (e) {
+              cont.promise.reject(e);
+            }
+          } else {
+            cont.promise.reject(error);
+          }
+        });
+      },
+      _runResolutions: function() {
+        if (this._paused || !this._isResolved() || this._isPending()) {
+          return;
+        }
+        var continuations = this._takeContinuations();
+        if (looksLikeAPromise(this._data)) {
+          return this._handleWhenResolvedDataIsPromise(this._data);
+        }
+        var data = this._data;
+        var self2 = this;
+        continuations.forEach(function(cont) {
+          if (cont.nextFn) {
+            try {
+              var result = cont.nextFn(data);
+              self2._handleUserFunctionResult(result, cont.promise);
+            } catch (e) {
+              self2._handleResolutionError(e, cont);
+            }
+          } else if (cont.promise) {
+            cont.promise.resolve(data);
+          }
+        });
+      },
+      _handleResolutionError: function(e, continuation) {
+        this._setRejected();
+        if (continuation.catchFn) {
+          try {
+            continuation.catchFn(e);
+            return;
+          } catch (e2) {
+            e = e2;
+          }
+        }
+        if (continuation.promise) {
+          continuation.promise.reject(e);
+        }
+      },
+      _handleWhenResolvedDataIsPromise: function(data) {
+        var self2 = this;
+        return data.then(function(result) {
+          self2._data = result;
+          self2._runResolutions();
+        }).catch(function(error) {
+          self2._error = error;
+          self2._setRejected();
+          self2._runRejections();
+        });
+      },
+      _handleUserFunctionResult: function(data, nextSynchronousPromise) {
+        if (looksLikeAPromise(data)) {
+          this._chainPromiseData(data, nextSynchronousPromise);
+        } else {
+          nextSynchronousPromise.resolve(data);
+        }
+      },
+      _chainPromiseData: function(promiseData, nextSynchronousPromise) {
+        promiseData.then(function(newData) {
+          nextSynchronousPromise.resolve(newData);
+        }).catch(function(newError) {
+          nextSynchronousPromise.reject(newError);
+        });
+      },
+      _setResolved: function() {
+        this.status = RESOLVED;
+        if (!this._paused) {
+          this._runResolutions();
+        }
+      },
+      _setRejected: function() {
+        this.status = REJECTED;
+        if (!this._paused) {
+          this._runRejections();
+        }
+      },
+      _isPending: function() {
+        return this.status === PENDING;
+      },
+      _isResolved: function() {
+        return this.status === RESOLVED;
+      },
+      _isRejected: function() {
+        return this.status === REJECTED;
+      }
+    };
+    SynchronousPromise4.resolve = function(result) {
+      return new SynchronousPromise4(function(resolve2, reject) {
+        if (looksLikeAPromise(result)) {
+          result.then(function(newResult) {
+            resolve2(newResult);
+          }).catch(function(error) {
+            reject(error);
+          });
+        } else {
+          resolve2(result);
+        }
+      });
+    };
+    SynchronousPromise4.reject = function(result) {
+      return new SynchronousPromise4(function(resolve2, reject) {
+        reject(result);
+      });
+    };
+    SynchronousPromise4.unresolved = function() {
+      return new SynchronousPromise4(function(resolve2, reject) {
+        this.resolve = resolve2;
+        this.reject = reject;
+      });
+    };
+    SynchronousPromise4.all = function() {
+      var args = makeArrayFrom(arguments);
+      if (Array.isArray(args[0])) {
+        args = args[0];
+      }
+      if (!args.length) {
+        return SynchronousPromise4.resolve([]);
+      }
+      return new SynchronousPromise4(function(resolve2, reject) {
+        var allData = [], numResolved = 0, doResolve = function() {
+          if (numResolved === args.length) {
+            resolve2(allData);
+          }
+        }, rejected = false, doReject = function(err) {
+          if (rejected) {
+            return;
+          }
+          rejected = true;
+          reject(err);
+        };
+        args.forEach(function(arg, idx) {
+          SynchronousPromise4.resolve(arg).then(function(thisResult) {
+            allData[idx] = thisResult;
+            numResolved += 1;
+            doResolve();
+          }).catch(function(err) {
+            doReject(err);
+          });
+        });
+      });
+    };
+    function createAggregateErrorFrom(errors) {
+      if (typeof window !== "undefined" && "AggregateError" in window) {
+        return new window.AggregateError(errors);
+      }
+      return { errors };
+    }
+    SynchronousPromise4.any = function() {
+      var args = makeArrayFrom(arguments);
+      if (Array.isArray(args[0])) {
+        args = args[0];
+      }
+      if (!args.length) {
+        return SynchronousPromise4.reject(createAggregateErrorFrom([]));
+      }
+      return new SynchronousPromise4(function(resolve2, reject) {
+        var allErrors = [], numRejected = 0, doReject = function() {
+          if (numRejected === args.length) {
+            reject(createAggregateErrorFrom(allErrors));
+          }
+        }, resolved = false, doResolve = function(result) {
+          if (resolved) {
+            return;
+          }
+          resolved = true;
+          resolve2(result);
+        };
+        args.forEach(function(arg, idx) {
+          SynchronousPromise4.resolve(arg).then(function(thisResult) {
+            doResolve(thisResult);
+          }).catch(function(err) {
+            allErrors[idx] = err;
+            numRejected += 1;
+            doReject();
+          });
+        });
+      });
+    };
+    SynchronousPromise4.allSettled = function() {
+      var args = makeArrayFrom(arguments);
+      if (Array.isArray(args[0])) {
+        args = args[0];
+      }
+      if (!args.length) {
+        return SynchronousPromise4.resolve([]);
+      }
+      return new SynchronousPromise4(function(resolve2) {
+        var allData = [], numSettled = 0, doSettled = function() {
+          numSettled += 1;
+          if (numSettled === args.length) {
+            resolve2(allData);
+          }
+        };
+        args.forEach(function(arg, idx) {
+          SynchronousPromise4.resolve(arg).then(function(thisResult) {
+            allData[idx] = {
+              status: "fulfilled",
+              value: thisResult
+            };
+            doSettled();
+          }).catch(function(err) {
+            allData[idx] = {
+              status: "rejected",
+              reason: err
+            };
+            doSettled();
+          });
+        });
+      });
+    };
+    if (Promise === SynchronousPromise4) {
+      throw new Error("Please use SynchronousPromise.installGlobally() to install globally");
+    }
+    var RealPromise = Promise;
+    SynchronousPromise4.installGlobally = function(__awaiter) {
+      if (Promise === SynchronousPromise4) {
+        return __awaiter;
+      }
+      var result = patchAwaiterIfRequired(__awaiter);
+      Promise = SynchronousPromise4;
+      return result;
+    };
+    SynchronousPromise4.uninstallGlobally = function() {
+      if (Promise === SynchronousPromise4) {
+        Promise = RealPromise;
+      }
+    };
+    function patchAwaiterIfRequired(__awaiter) {
+      if (typeof __awaiter === "undefined" || __awaiter.__patched) {
+        return __awaiter;
+      }
+      var originalAwaiter = __awaiter;
+      __awaiter = function() {
+        var Promise3 = RealPromise;
+        originalAwaiter.apply(this, makeArrayFrom(arguments));
+      };
+      __awaiter.__patched = true;
+      return __awaiter;
+    }
+    module2.exports = {
+      SynchronousPromise: SynchronousPromise4
+    };
+  }
+});
+
 // node_modules/property-expr/index.js
 var require_property_expr = __commonJS({
   "node_modules/property-expr/index.js"(exports2, module2) {
@@ -8125,7 +8559,6 @@ var date = {
   min: "${path} field must be later than ${min}",
   max: "${path} field must be at earlier than ${max}"
 };
-var boolean = {};
 var object = {
   noUnknown: "${path} field has unspecified keys: ${unknown}"
 };
@@ -8133,15 +8566,6 @@ var array = {
   min: "${path} field must have at least ${min} items",
   max: "${path} field must have less than or equal to ${max} items"
 };
-var locale_default = _extends(/* @__PURE__ */ Object.create(null), {
-  mixed,
-  string,
-  number,
-  date,
-  object,
-  array,
-  boolean
-});
 
 // node_modules/yup/es/util/isSchema.js
 var isSchema_default = function(obj) {
@@ -8186,7 +8610,7 @@ var Condition = /* @__PURE__ */ function() {
   var _proto = Condition2.prototype;
   _proto.resolve = function resolve2(base, options) {
     var values2 = this.refs.map(function(ref) {
-      return ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
+      return ref.getValue(options);
     });
     var schema = this.fn.apply(base, values2.concat(base, options));
     if (schema === void 0 || schema === base)
@@ -8199,8 +8623,34 @@ var Condition = /* @__PURE__ */ function() {
 }();
 var Condition_default = Condition;
 
+// node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null)
+    return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0)
+      continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+// node_modules/yup/es/util/runValidations.js
+var import_synchronous_promise = __toESM(require_synchronous_promise());
+
 // node_modules/yup/es/ValidationError.js
 var strReg = /\$\{\s*(\w+)\s*\}/g;
+var replace = function replace2(str) {
+  return function(params) {
+    return str.replace(strReg, function(_, key) {
+      return printValue(params[key]);
+    });
+  };
+};
 function ValidationError(errors, value, field, type) {
   var _this = this;
   this.name = "ValidationError";
@@ -8225,65 +8675,85 @@ ValidationError.isError = function(err) {
   return err && err.name === "ValidationError";
 };
 ValidationError.formatError = function(message, params) {
-  params.path = params.label || params.path || "this";
   if (typeof message === "string")
-    return message.replace(strReg, function(_, key) {
-      return printValue(params[key]);
-    });
-  if (typeof message === "function")
-    return message(params);
-  return message;
-};
-
-// node_modules/yup/es/util/async.js
-var once = function once2(cb) {
-  var fired = false;
-  return function() {
-    if (fired)
-      return;
-    fired = true;
-    cb.apply(void 0, arguments);
+    message = replace(message);
+  var fn = function fn2(params2) {
+    params2.path = params2.label || params2.path || "this";
+    return typeof message === "function" ? message(params2) : message;
   };
+  return arguments.length === 1 ? fn : fn(params);
 };
 
-// node_modules/yup/es/util/runTests.js
-function runTests(options, cb) {
-  var endEarly = options.endEarly, tests = options.tests, args = options.args, value = options.value, errors = options.errors, sort = options.sort, path = options.path;
-  var callback = once(cb);
-  var count = tests.length;
-  if (!count)
-    return callback(null, value);
-  var nestedErrors = [];
-  errors = errors ? errors : [];
-  for (var i = 0; i < tests.length; i++) {
-    var test2 = tests[i];
-    test2(args, function finishTestRun(err) {
-      if (err) {
-        if (!ValidationError.isError(err)) {
-          return callback(err);
-        }
-        if (endEarly) {
-          err.value = value;
-          return callback(err);
-        }
-        nestedErrors.push(err);
-      }
-      if (--count <= 0) {
-        if (nestedErrors.length) {
-          if (sort)
-            nestedErrors.sort(sort);
-          if (errors.length)
-            nestedErrors.push.apply(nestedErrors, errors);
-          errors = nestedErrors;
-        }
-        if (errors.length) {
-          callback(new ValidationError(errors, value, path));
-          return;
-        }
-        callback(null, value);
-      }
-    });
+// node_modules/yup/es/util/runValidations.js
+var promise = function promise2(sync) {
+  return sync ? import_synchronous_promise.SynchronousPromise : Promise;
+};
+var unwrapError = function unwrapError2(errors) {
+  if (errors === void 0) {
+    errors = [];
   }
+  return errors.inner && errors.inner.length ? errors.inner : [].concat(errors);
+};
+function scopeToValue(promises, value, sync) {
+  var p = promise(sync).all(promises);
+  var b = p.catch(function(err) {
+    if (err.name === "ValidationError")
+      err.value = value;
+    throw err;
+  });
+  var c = b.then(function() {
+    return value;
+  });
+  return c;
+}
+function propagateErrors(endEarly, errors) {
+  return endEarly ? null : function(err) {
+    errors.push(err);
+    return err.value;
+  };
+}
+function settled(promises, sync) {
+  var Promise3 = promise(sync);
+  return Promise3.all(promises.map(function(p) {
+    return Promise3.resolve(p).then(function(value) {
+      return {
+        fulfilled: true,
+        value
+      };
+    }, function(value) {
+      return {
+        fulfilled: false,
+        value
+      };
+    });
+  }));
+}
+function collectErrors(_ref) {
+  var validations = _ref.validations, value = _ref.value, path = _ref.path, sync = _ref.sync, errors = _ref.errors, sort = _ref.sort;
+  errors = unwrapError(errors);
+  return settled(validations, sync).then(function(results) {
+    var nestedErrors = results.filter(function(r) {
+      return !r.fulfilled;
+    }).reduce(function(arr, _ref2) {
+      var error = _ref2.value;
+      if (!ValidationError.isError(error)) {
+        throw error;
+      }
+      return arr.concat(error);
+    }, []);
+    if (sort)
+      nestedErrors.sort(sort);
+    errors = nestedErrors.concat(errors);
+    if (errors.length)
+      throw new ValidationError(errors, value, path);
+    return value;
+  });
+}
+function runValidations(_ref3) {
+  var endEarly = _ref3.endEarly, options = _objectWithoutPropertiesLoose(_ref3, ["endEarly"]);
+  if (endEarly)
+    return scopeToValue(options.validations, options.value, options.sync);
+  return collectErrors(options);
 }
 
 // node_modules/yup/es/util/prependDeep.js
@@ -8313,22 +8783,6 @@ function prependDeep(target, source) {
   return target;
 }
 
-// node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null)
-    return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0)
-      continue;
-    target[key] = source[key];
-  }
-  return target;
-}
-
 // node_modules/lodash-es/_createBaseFor.js
 function createBaseFor(fromRight) {
   return function(object2, iteratee, keysFunc) {
@@ -8809,8 +9263,8 @@ var Reference = /* @__PURE__ */ function() {
     this.map = options.map;
   }
   var _proto = Reference2.prototype;
-  _proto.getValue = function getValue2(value, parent, context) {
-    var result = this.isContext ? context : this.isValue ? value : parent;
+  _proto.getValue = function getValue2(options) {
+    var result = this.isContext ? options.context : this.isValue ? options.value : options.parent;
     if (this.getter)
       result = this.getter(result || {});
     if (this.map)
@@ -8818,7 +9272,9 @@ var Reference = /* @__PURE__ */ function() {
     return result;
   };
   _proto.cast = function cast2(value, options) {
-    return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
+    return this.getValue(_extends({}, options, {
+      value
+    }));
   };
   _proto.resolve = function resolve2() {
     return this;
@@ -8840,71 +9296,76 @@ var Reference = /* @__PURE__ */ function() {
 Reference.prototype.__isYupRef = true;
 
 // node_modules/yup/es/util/createValidation.js
-function createValidation(config) {
-  function validate2(_ref, cb) {
-    var value = _ref.value, path = _ref.path, label2 = _ref.label, options = _ref.options, originalValue = _ref.originalValue, sync = _ref.sync, rest = _objectWithoutPropertiesLoose(_ref, ["value", "path", "label", "options", "originalValue", "sync"]);
-    var name = config.name, test2 = config.test, params = config.params, message = config.message;
-    var parent = options.parent, context = options.context;
-    function resolve2(item) {
-      return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
-    }
-    function createError(overrides) {
-      if (overrides === void 0) {
-        overrides = {};
-      }
-      var nextParams = mapValues_default(_extends({
+var import_synchronous_promise2 = __toESM(require_synchronous_promise());
+var formatError = ValidationError.formatError;
+var thenable = function thenable2(p) {
+  return p && typeof p.then === "function" && typeof p.catch === "function";
+};
+function runTest(testFn, ctx, value, sync) {
+  var result = testFn.call(ctx, value);
+  if (!sync)
+    return Promise.resolve(result);
+  if (thenable(result)) {
+    throw new Error('Validation test of type: "' + ctx.type + '" returned a Promise during a synchronous validate. This test will finish after the validate call has returned');
+  }
+  return import_synchronous_promise2.SynchronousPromise.resolve(result);
+}
+function resolveParams(oldParams, newParams, resolve2) {
+  return mapValues_default(_extends({}, oldParams, newParams), resolve2);
+}
+function createErrorFactory(_ref) {
+  var value = _ref.value, label2 = _ref.label, resolve2 = _ref.resolve, originalValue = _ref.originalValue, opts = _objectWithoutPropertiesLoose(_ref, ["value", "label", "resolve", "originalValue"]);
+  return function createError(_temp) {
+    var _ref2 = _temp === void 0 ? {} : _temp, _ref2$path = _ref2.path, path = _ref2$path === void 0 ? opts.path : _ref2$path, _ref2$message = _ref2.message, message = _ref2$message === void 0 ? opts.message : _ref2$message, _ref2$type = _ref2.type, type = _ref2$type === void 0 ? opts.name : _ref2$type, params = _ref2.params;
+    params = _extends({
+      path,
+      value,
+      originalValue,
+      label: label2
+    }, resolveParams(opts.params, params, resolve2));
+    return _extends(new ValidationError(formatError(message, params), value, path, type), {
+      params
+    });
+  };
+}
+function createValidation(options) {
+  var name = options.name, message = options.message, test2 = options.test, params = options.params;
+  function validate2(_ref3) {
+    var value = _ref3.value, path = _ref3.path, label2 = _ref3.label, options2 = _ref3.options, originalValue = _ref3.originalValue, sync = _ref3.sync, rest = _objectWithoutPropertiesLoose(_ref3, ["value", "path", "label", "options", "originalValue", "sync"]);
+    var parent = options2.parent;
+    var resolve2 = function resolve3(item) {
+      return Reference.isRef(item) ? item.getValue({
         value,
-        originalValue,
-        label: label2,
-        path: overrides.path || path
-      }, params, overrides.params), resolve2);
-      var error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name);
-      error.params = nextParams;
-      return error;
-    }
+        parent,
+        context: options2.context
+      }) : item;
+    };
+    var createError = createErrorFactory({
+      message,
+      path,
+      value,
+      originalValue,
+      params,
+      label: label2,
+      resolve: resolve2,
+      name
+    });
     var ctx = _extends({
       path,
       parent,
       type: name,
       createError,
       resolve: resolve2,
-      options,
-      originalValue
+      options: options2
     }, rest);
-    if (!sync) {
-      try {
-        Promise.resolve(test2.call(ctx, value, ctx)).then(function(validOrError) {
-          if (ValidationError.isError(validOrError))
-            cb(validOrError);
-          else if (!validOrError)
-            cb(createError());
-          else
-            cb(null, validOrError);
-        });
-      } catch (err) {
-        cb(err);
-      }
-      return;
-    }
-    var result;
-    try {
-      var _result;
-      result = test2.call(ctx, value, ctx);
-      if (typeof ((_result = result) == null ? void 0 : _result.then) === "function") {
-        throw new Error('Validation test of type: "' + ctx.type + '" returned a Promise during a synchronous validate. This test will finish after the validate call has returned');
-      }
-    } catch (err) {
-      cb(err);
-      return;
-    }
-    if (ValidationError.isError(result))
-      cb(result);
-    else if (!result)
-      cb(createError());
-    else
-      cb(null, result);
+    return runTest(test2, ctx, value, sync).then(function(validOrError) {
+      if (ValidationError.isError(validOrError))
+        throw validOrError;
+      else if (!validOrError)
+        throw createError();
+    });
   }
-  validate2.OPTIONS = config;
+  validate2.OPTIONS = options;
   return validate2;
 }
 
@@ -9097,12 +9558,9 @@ var proto = SchemaType.prototype = {
     var _this2 = this;
     if (this._mutate)
       return this;
-    return cloneDeepWith_default(this, function(value, key) {
+    return cloneDeepWith_default(this, function(value) {
       if (isSchema_default(value) && value !== _this2)
         return value;
-      if (key === "_whitelist" || key === "_blacklist") {
-        return value.clone();
-      }
     });
   },
   label: function label(_label) {
@@ -9161,20 +9619,13 @@ var proto = SchemaType.prototype = {
     }
     return schema;
   },
-  /**
-   *
-   * @param {*} value
-   * @param {Object} options
-   * @param {*=} options.parent
-   * @param {*=} options.context
-   */
   cast: function cast(value, options) {
     if (options === void 0) {
       options = {};
     }
-    var resolvedSchema = this.resolve(_extends({
+    var resolvedSchema = this.resolve(_extends({}, options, {
       value
-    }, options));
+    }));
     var result = resolvedSchema._cast(value, options);
     if (value !== void 0 && options.assert !== false && resolvedSchema.isType(result) !== true) {
       var formattedValue = printValue(value);
@@ -9193,72 +9644,68 @@ var proto = SchemaType.prototype = {
     }
     return value;
   },
-  _validate: function _validate(_value, options, cb) {
+  _validate: function _validate(_value, options) {
     var _this4 = this;
     if (options === void 0) {
       options = {};
     }
-    var _options = options, sync = _options.sync, path = _options.path, _options$from = _options.from, from2 = _options$from === void 0 ? [] : _options$from, _options$originalValu = _options.originalValue, originalValue = _options$originalValu === void 0 ? _value : _options$originalValu, _options$strict = _options.strict, strict2 = _options$strict === void 0 ? this._options.strict : _options$strict, _options$abortEarly = _options.abortEarly, abortEarly = _options$abortEarly === void 0 ? this._options.abortEarly : _options$abortEarly;
     var value = _value;
-    if (!strict2) {
-      this._validating = true;
+    var originalValue = options.originalValue != null ? options.originalValue : _value;
+    var isStrict = this._option("strict", options);
+    var endEarly = this._option("abortEarly", options);
+    var sync = options.sync;
+    var path = options.path;
+    var label2 = this._label;
+    if (!isStrict) {
       value = this._cast(value, _extends({
         assert: false
       }, options));
-      this._validating = false;
     }
-    var args = {
+    var validationParams = {
       value,
       path,
+      schema: this,
       options,
+      label: label2,
       originalValue,
-      schema: this,
-      label: this._label,
-      sync,
-      from: from2
+      sync
     };
+    if (options.from) {
+      validationParams.from = options.from;
+    }
     var initialTests = [];
     if (this._typeError)
-      initialTests.push(this._typeError);
+      initialTests.push(this._typeError(validationParams));
     if (this._whitelistError)
-      initialTests.push(this._whitelistError);
+      initialTests.push(this._whitelistError(validationParams));
     if (this._blacklistError)
-      initialTests.push(this._blacklistError);
-    return runTests({
-      args,
+      initialTests.push(this._blacklistError(validationParams));
+    return runValidations({
+      validations: initialTests,
+      endEarly,
       value,
       path,
-      sync,
-      tests: initialTests,
-      endEarly: abortEarly
-    }, function(err) {
-      if (err)
-        return void cb(err);
-      runTests({
-        tests: _this4.tests,
-        args,
+      sync
+    }).then(function(value2) {
+      return runValidations({
         path,
         sync,
-        value,
-        endEarly: abortEarly
-      }, cb);
+        value: value2,
+        endEarly,
+        validations: _this4.tests.map(function(fn) {
+          return fn(validationParams);
+        })
+      });
     });
   },
-  validate: function validate(value, options, maybeCb) {
+  validate: function validate(value, options) {
     if (options === void 0) {
       options = {};
     }
     var schema = this.resolve(_extends({}, options, {
       value
     }));
-    return typeof maybeCb === "function" ? schema._validate(value, options, maybeCb) : new Promise(function(resolve2, reject) {
-      return schema._validate(value, options, function(err, value2) {
-        if (err)
-          reject(err);
-        else
-          resolve2(value2);
-      });
-    });
+    return schema._validate(value, options);
   },
   validateSync: function validateSync(value, options) {
     if (options === void 0) {
@@ -9267,14 +9714,16 @@ var proto = SchemaType.prototype = {
     var schema = this.resolve(_extends({}, options, {
       value
     }));
-    var result;
+    var result, err;
     schema._validate(value, _extends({}, options, {
       sync: true
-    }), function(err, value2) {
-      if (err)
-        throw err;
-      result = value2;
+    })).then(function(r) {
+      return result = r;
+    }).catch(function(e) {
+      return err = e;
     });
+    if (err)
+      throw err;
     return result;
   },
   isValid: function isValid(value, options) {
@@ -9534,7 +9983,7 @@ var proto = SchemaType.prototype = {
     if (message === void 0) {
       message = mixed.defined;
     }
-    return this.test({
+    return this.nullable().test({
       message,
       name: "defined",
       exclusive: true,
@@ -9628,7 +10077,7 @@ var isAbsent_default = function(value) {
 // node_modules/yup/es/string.js
 var rEmail = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
 var rUrl = /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
-var rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+var rUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var isTrimmed = function isTrimmed2(value) {
   return isAbsent_default(value) || value === value.trim();
 };
@@ -10043,6 +10492,15 @@ inherits(DateSchema, SchemaType, {
   }
 });
 
+// node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js
+function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+  strings.raw = raw;
+  return strings;
+}
+
 // node_modules/lodash-es/_arrayReduce.js
 function arrayReduce(array2, iteratee, accumulator, initAccum) {
   var index = -1, length2 = array2 == null ? 0 : array2.length;
@@ -10450,8 +10908,7 @@ function sortFields(fields, excludes) {
   if (excludes === void 0) {
     excludes = [];
   }
-  var edges = [];
-  var nodes = [];
+  var edges = [], nodes = [];
   function addNode(depPath, key2) {
     var node = (0, import_property_expr3.split)(depPath)[0];
     if (!~nodes.indexOf(node))
@@ -10459,21 +10916,18 @@ function sortFields(fields, excludes) {
     if (!~excludes.indexOf(key2 + "-" + node))
       edges.push([key2, node]);
   }
-  var _loop3 = function _loop4(key2) {
-    if (has_default(fields, key2)) {
-      var value = fields[key2];
-      if (!~nodes.indexOf(key2))
-        nodes.push(key2);
+  for (var key in fields) {
+    if (has_default(fields, key)) {
+      var value = fields[key];
+      if (!~nodes.indexOf(key))
+        nodes.push(key);
       if (Reference.isRef(value) && value.isSibling)
-        addNode(value.path, key2);
+        addNode(value.path, key);
       else if (isSchema_default(value) && value._deps)
         value._deps.forEach(function(path) {
-          return addNode(path, key2);
+          return addNode(path, key);
         });
     }
-  };
-  for (var key in fields) {
-    _loop3(key);
   }
   return import_toposort.default.array(nodes, edges).reverse();
 }
@@ -10489,55 +10943,54 @@ function findIndex(arr, err) {
   });
   return idx;
 }
-function sortByKeyOrder(keys2) {
+function sortByKeyOrder(fields) {
+  var keys2 = Object.keys(fields);
   return function(a, b) {
     return findIndex(keys2, a) - findIndex(keys2, b);
   };
 }
 
-// node_modules/yup/es/object.js
-function _createForOfIteratorHelperLoose2(o, allowArrayLike) {
-  var it;
-  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray2(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it)
-        o = it;
-      var i = 0;
-      return function() {
-        if (i >= o.length)
-          return { done: true };
-        return { done: false, value: o[i++] };
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+// node_modules/yup/es/util/makePath.js
+function makePath(strings) {
+  for (var _len = arguments.length, values2 = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    values2[_key - 1] = arguments[_key];
   }
-  it = o[Symbol.iterator]();
-  return it.next.bind(it);
+  var path = strings.reduce(function(str, next) {
+    var value = values2.shift();
+    return str + (value == null ? "" : value) + next;
+  });
+  return path.replace(/^\./, "");
 }
-function _unsupportedIterableToArray2(o, minLen) {
-  if (!o)
-    return;
-  if (typeof o === "string")
-    return _arrayLikeToArray2(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor)
-    n = o.constructor.name;
-  if (n === "Map" || n === "Set")
-    return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-    return _arrayLikeToArray2(o, minLen);
+
+// node_modules/yup/es/object.js
+var import_synchronous_promise3 = __toESM(require_synchronous_promise());
+function _templateObject3() {
+  var data = _taggedTemplateLiteralLoose(["", '["', '"]']);
+  _templateObject3 = function _templateObject32() {
+    return data;
+  };
+  return data;
 }
-function _arrayLikeToArray2(arr, len) {
-  if (len == null || len > arr.length)
-    len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
-  return arr2;
+function _templateObject2() {
+  var data = _taggedTemplateLiteralLoose(["", ".", ""]);
+  _templateObject2 = function _templateObject23() {
+    return data;
+  };
+  return data;
+}
+function _templateObject() {
+  var data = _taggedTemplateLiteralLoose(["", ".", ""]);
+  _templateObject = function _templateObject5() {
+    return data;
+  };
+  return data;
 }
 var isObject4 = function isObject5(obj) {
   return Object.prototype.toString.call(obj) === "[object Object]";
 };
+var promise3 = function promise4(sync) {
+  return sync ? import_synchronous_promise3.SynchronousPromise : Promise;
+};
 function unknown(ctx, value) {
   var known = Object.keys(ctx.fields);
   return Object.keys(value).filter(function(key) {
@@ -10562,7 +11015,6 @@ function ObjectSchema(spec) {
     }
   });
   this.fields = /* @__PURE__ */ Object.create(null);
-  this._sortErrors = sortByKeyOrder([]);
   this._nodes = [];
   this._excludedEdges = [];
   this.withMutation(function() {
@@ -10592,7 +11044,7 @@ inherits(ObjectSchema, SchemaType, {
     if (options === void 0) {
       options = {};
     }
-    var value = SchemaType.prototype._cast.call(this, _value);
+    var value = SchemaType.prototype._cast.call(this, _value, options);
     if (value === void 0)
       return this.default();
     if (!this._typeCheck(value))
@@ -10608,111 +11060,84 @@ inherits(ObjectSchema, SchemaType, {
       __validating: options.__validating || false
     });
     var isChanged = false;
-    for (var _iterator = _createForOfIteratorHelperLoose2(props), _step; !(_step = _iterator()).done; ) {
-      var prop = _step.value;
+    props.forEach(function(prop) {
       var field = fields[prop];
       var exists = has_default(value, prop);
       if (field) {
-        var fieldValue = void 0;
+        var fieldValue;
         var strict2 = field._options && field._options.strict;
-        innerOptions.path = (options.path ? options.path + "." : "") + prop;
+        innerOptions.path = makePath(_templateObject(), options.path, prop);
         innerOptions.value = value[prop];
         field = field.resolve(innerOptions);
         if (field._strip === true) {
           isChanged = isChanged || prop in value;
-          continue;
+          return;
         }
         fieldValue = !options.__validating || !strict2 ? field.cast(value[prop], innerOptions) : value[prop];
-        if (fieldValue !== void 0) {
+        if (fieldValue !== void 0)
           intermediateValue[prop] = fieldValue;
-        }
-      } else if (exists && !strip2) {
+      } else if (exists && !strip2)
         intermediateValue[prop] = value[prop];
-      }
-      if (intermediateValue[prop] !== value[prop]) {
+      if (intermediateValue[prop] !== value[prop])
         isChanged = true;
-      }
-    }
+    });
     return isChanged ? intermediateValue : value;
   },
-  /**
-   * @typedef {Object} Ancestor
-   * @property {Object} schema - a string property of SpecialType
-   * @property {*} value - a number property of SpecialType
-   */
-  /**
-   *
-   * @param {*} _value
-   * @param {Object}       opts
-   * @param {string=}      opts.path
-   * @param {*=}           opts.parent
-   * @param {Object=}      opts.context
-   * @param {boolean=}     opts.sync
-   * @param {boolean=}     opts.stripUnknown
-   * @param {boolean=}     opts.strict
-   * @param {boolean=}     opts.recursive
-   * @param {boolean=}     opts.abortEarly
-   * @param {boolean=}     opts.__validating
-   * @param {Object=}      opts.originalValue
-   * @param {Ancestor[]=}  opts.from
-   * @param {Object}       [opts.from]
-   * @param {Function}     callback
-   */
-  _validate: function _validate2(_value, opts, callback) {
+  _validate: function _validate2(_value, opts) {
     var _this4 = this;
     if (opts === void 0) {
       opts = {};
     }
+    var endEarly, recursive;
+    var sync = opts.sync;
     var errors = [];
-    var _opts = opts, sync = _opts.sync, _opts$from = _opts.from, from2 = _opts$from === void 0 ? [] : _opts$from, _opts$originalValue = _opts.originalValue, originalValue = _opts$originalValue === void 0 ? _value : _opts$originalValue, _opts$abortEarly = _opts.abortEarly, abortEarly = _opts$abortEarly === void 0 ? this._options.abortEarly : _opts$abortEarly, _opts$recursive = _opts.recursive, recursive = _opts$recursive === void 0 ? this._options.recursive : _opts$recursive;
-    from2 = [{
+    var originalValue = opts.originalValue != null ? opts.originalValue : _value;
+    var from2 = [{
       schema: this,
       value: originalValue
-    }].concat(from2);
-    opts.__validating = true;
-    opts.originalValue = originalValue;
-    opts.from = from2;
-    SchemaType.prototype._validate.call(this, _value, opts, function(err, value) {
-      if (err) {
-        if (abortEarly)
-          return void callback(err);
-        errors.push(err);
-        value = err.value;
-      }
+    }].concat(opts.from || []);
+    endEarly = this._option("abortEarly", opts);
+    recursive = this._option("recursive", opts);
+    opts = _extends({}, opts, {
+      __validating: true,
+      originalValue,
+      from: from2
+    });
+    return SchemaType.prototype._validate.call(this, _value, opts).catch(propagateErrors(endEarly, errors)).then(function(value) {
       if (!recursive || !isObject4(value)) {
-        callback(errors[0] || null, value);
-        return;
+        if (errors.length)
+          throw errors[0];
+        return value;
       }
+      from2 = originalValue ? [].concat(from2) : [{
+        schema: _this4,
+        value: originalValue || value
+      }].concat(opts.from || []);
       originalValue = originalValue || value;
-      var tests = _this4._nodes.map(function(key) {
-        return function(_, cb) {
-          var path = key.indexOf(".") === -1 ? (opts.path ? opts.path + "." : "") + key : (opts.path || "") + '["' + key + '"]';
-          var field = _this4.fields[key];
-          if (field && field.validate) {
-            field.validate(value[key], _extends({}, opts, {
-              path,
-              from: from2,
-              // inner fields are always strict:
-              // 1. this isn't strict so the casting will also have cast inner values
-              // 2. this is strict in which case the nested values weren't cast either
-              strict: true,
-              parent: value,
-              originalValue: originalValue[key]
-            }), cb);
-            return;
-          }
-          cb(null);
-        };
+      var validations = _this4._nodes.map(function(key) {
+        var path = key.indexOf(".") === -1 ? makePath(_templateObject2(), opts.path, key) : makePath(_templateObject3(), opts.path, key);
+        var field = _this4.fields[key];
+        var innerOptions = _extends({}, opts, {
+          path,
+          from: from2,
+          parent: value,
+          originalValue: originalValue[key]
+        });
+        if (field && field.validate) {
+          innerOptions.strict = true;
+          return field.validate(value[key], innerOptions);
+        }
+        return promise3(sync).resolve(true);
       });
-      runTests({
+      return runValidations({
         sync,
-        tests,
+        validations,
         value,
         errors,
-        endEarly: abortEarly,
-        sort: _this4._sortErrors,
-        path: opts.path
-      }, callback);
+        endEarly,
+        path: opts.path,
+        sort: sortByKeyOrder(_this4.fields)
+      });
     });
   },
   concat: function concat2(schema) {
@@ -10727,7 +11152,6 @@ inherits(ObjectSchema, SchemaType, {
     var next = this.clone();
     var fields = _extends(next.fields, schema);
     next.fields = fields;
-    next._sortErrors = sortByKeyOrder(Object.keys(fields));
     if (excludes.length) {
       if (!Array.isArray(excludes[0]))
         excludes = [excludes];
@@ -10821,6 +11245,20 @@ inherits(ObjectSchema, SchemaType, {
 });
 
 // node_modules/yup/es/array.js
+function _templateObject22() {
+  var data = _taggedTemplateLiteralLoose(["", "[", "]"]);
+  _templateObject22 = function _templateObject23() {
+    return data;
+  };
+  return data;
+}
+function _templateObject4() {
+  var data = _taggedTemplateLiteralLoose(["", "[", "]"]);
+  _templateObject4 = function _templateObject5() {
+    return data;
+  };
+  return data;
+}
 var array_default = ArraySchema;
 function ArraySchema(type) {
   var _this = this;
@@ -10857,7 +11295,7 @@ inherits(ArraySchema, SchemaType, {
     var isChanged = false;
     var castArray = value.map(function(v, idx) {
       var castElement = _this2.innerType.cast(v, _extends({}, _opts, {
-        path: (_opts.path || "") + "[" + idx + "]"
+        path: makePath(_templateObject4(), _opts.path, idx)
       }));
       if (castElement !== v) {
         isChanged = true;
@@ -10866,7 +11304,7 @@ inherits(ArraySchema, SchemaType, {
     });
     return isChanged ? castArray : value;
   },
-  _validate: function _validate3(_value, options, callback) {
+  _validate: function _validate3(_value, options) {
     var _this3 = this;
     if (options === void 0) {
       options = {};
@@ -10878,44 +11316,34 @@ inherits(ArraySchema, SchemaType, {
     var endEarly = this._option("abortEarly", options);
     var recursive = this._option("recursive", options);
     var originalValue = options.originalValue != null ? options.originalValue : _value;
-    SchemaType.prototype._validate.call(this, _value, options, function(err, value) {
-      if (err) {
-        if (endEarly)
-          return void callback(err);
-        errors.push(err);
-        value = err.value;
-      }
+    return SchemaType.prototype._validate.call(this, _value, options).catch(propagateErrors(endEarly, errors)).then(function(value) {
       if (!recursive || !innerType || !_this3._typeCheck(value)) {
-        callback(errors[0] || null, value);
-        return;
+        if (errors.length)
+          throw errors[0];
+        return value;
       }
       originalValue = originalValue || value;
-      var tests = new Array(value.length);
-      var _loop3 = function _loop4(idx2) {
-        var item = value[idx2];
-        var path2 = (options.path || "") + "[" + idx2 + "]";
+      var validations = new Array(value.length);
+      for (var idx = 0; idx < value.length; idx++) {
+        var item = value[idx];
+        var _path = makePath(_templateObject22(), options.path, idx);
         var innerOptions = _extends({}, options, {
-          path: path2,
+          path: _path,
           strict: true,
           parent: value,
-          index: idx2,
-          originalValue: originalValue[idx2]
+          index: idx,
+          originalValue: originalValue[idx]
         });
-        tests[idx2] = function(_, cb) {
-          return innerType.validate ? innerType.validate(item, innerOptions, cb) : cb(null);
-        };
-      };
-      for (var idx = 0; idx < value.length; idx++) {
-        _loop3(idx);
+        validations[idx] = innerType.validate ? innerType.validate(item, innerOptions) : true;
       }
-      runTests({
+      return runValidations({
         sync,
         path,
         value,
         errors,
         endEarly,
-        tests
-      }, callback);
+        validations
+      });
     });
   },
   _isPresent: function _isPresent3(value) {
@@ -11002,8 +11430,8 @@ var Lazy = /* @__PURE__ */ function() {
   _proto.cast = function cast2(value, options) {
     return this._resolve(value, options).cast(value, options);
   };
-  _proto.validate = function validate2(value, options, maybeCb) {
-    return this._resolve(value, options).validate(value, options, maybeCb);
+  _proto.validate = function validate2(value, options) {
+    return this._resolve(value, options).validate(value, options);
   };
   _proto.validateSync = function validateSync2(value, options) {
     return this._resolve(value, options).validateSync(value, options);
@@ -11020,7 +11448,7 @@ Lazy.prototype.__isYupSchema__ = true;
 var Lazy_default = Lazy;
 
 // node_modules/yup/es/index.js
-var boolean2 = boolean_default;
+var boolean = boolean_default;
 var lazy = function lazy2(fn) {
   return new Lazy_default(fn);
 };
@@ -11311,8 +11739,18 @@ var baseString = StringSchema().trim();
 var todayDateHint = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
 var convertBytesToKB = convertDiskSizeFromTo("Bytes", "KB");
 var convertKbBytesToMB = convertDiskSizeFromTo("KB", "MB");
+var validateOnlyStrings = StringSchema().trim().nullable().test(
+  "is-string",
+  "${path} must be a `string` type, but the final value was: `${value}`.",
+  (value, context) => {
+    if (context.originalValue !== null && context.originalValue !== void 0) {
+      return typeof context.originalValue === "string";
+    }
+    return true;
+  }
+);
 var yupSchemas = {
-  text: StringSchema().trim().nullable(),
+  text: validateOnlyStrings,
   select: StringSchema().trim().nullable(),
   radio: StringSchema().trim().nullable(),
   date: StringSchema().nullable().trim().matches(
@@ -11324,7 +11762,7 @@ var yupSchemas = {
   email: StringSchema().trim().email("Please enter a valid email address").nullable(),
   fieldset: ObjectSchema().nullable(),
   checkbox: StringSchema().trim().nullable(),
-  checkboxBool: boolean2(),
+  checkboxBool: boolean(),
   multiple: {
     select: array_default().nullable(),
     "group-array": array_default().nullable()
@@ -11734,12 +12172,26 @@ function updateFieldsProperties(fields, formValues, jsonSchema) {
   clearValuesIfNotVisible(fields, formValues);
 }
 var notNullOption = (opt) => opt.const !== null;
+function flatPresentation(item) {
+  return Object.entries(item).reduce((newItem, [key, value]) => {
+    if (key === "x-jsf-presentation") {
+      return {
+        ...newItem,
+        ...value
+      };
+    }
+    return {
+      ...newItem,
+      [key]: value
+    };
+  }, {});
+}
 function getFieldOptions(node, presentation) {
   function convertToOptions(nodeOptions) {
     return nodeOptions.filter(notNullOption).map(({ title, const: cons, ...item }) => ({
       label: title,
       value: cons,
-      ...item
+      ...flatPresentation(item)
     }));
   }
   if (presentation.options) {