@croz/nrich-form-configuration-core/dist/index.mjs

Contains core utilities related to the nrich-form-configuration module

import {
  __async,
  __commonJS,
  __objRest,
  __spreadProps,
  __spreadValues,
  __toESM,
  require_Stack,
  require_Uint8Array,
  require_arrayLikeKeys,
  require_baseGetTag,
  require_eq,
  require_getNative,
  require_identity,
  require_isArguments,
  require_isArray,
  require_isArrayLike,
  require_isBuffer,
  require_isFunction,
  require_isIndex,
  require_isObject,
  require_isObjectLike,
  require_isPrototype,
  require_isTypedArray,
  require_overArg,
  require_root,
  require_uniqBy
} from "./chunk-IX4UG67P.mjs";

// ../../../node_modules/lodash/_defineProperty.js
var require_defineProperty = __commonJS({
  "../../../node_modules/lodash/_defineProperty.js"(exports, module) {
    var getNative = require_getNative();
    var defineProperty = function() {
      try {
        var func = getNative(Object, "defineProperty");
        func({}, "", {});
        return func;
      } catch (e) {
      }
    }();
    module.exports = defineProperty;
  }
});

// ../../../node_modules/lodash/_baseAssignValue.js
var require_baseAssignValue = __commonJS({
  "../../../node_modules/lodash/_baseAssignValue.js"(exports, module) {
    var defineProperty = require_defineProperty();
    function baseAssignValue(object2, key, value) {
      if (key == "__proto__" && defineProperty) {
        defineProperty(object2, key, {
          "configurable": true,
          "enumerable": true,
          "value": value,
          "writable": true
        });
      } else {
        object2[key] = value;
      }
    }
    module.exports = baseAssignValue;
  }
});

// ../../../node_modules/lodash/_assignMergeValue.js
var require_assignMergeValue = __commonJS({
  "../../../node_modules/lodash/_assignMergeValue.js"(exports, module) {
    var baseAssignValue = require_baseAssignValue();
    var eq = require_eq();
    function assignMergeValue(object2, key, value) {
      if (value !== void 0 && !eq(object2[key], value) || value === void 0 && !(key in object2)) {
        baseAssignValue(object2, key, value);
      }
    }
    module.exports = assignMergeValue;
  }
});

// ../../../node_modules/lodash/_createBaseFor.js
var require_createBaseFor = __commonJS({
  "../../../node_modules/lodash/_createBaseFor.js"(exports, module) {
    function createBaseFor(fromRight) {
      return function(object2, iteratee, keysFunc) {
        var index = -1, iterable = Object(object2), props = keysFunc(object2), length = props.length;
        while (length--) {
          var key = props[fromRight ? length : ++index];
          if (iteratee(iterable[key], key, iterable) === false) {
            break;
          }
        }
        return object2;
      };
    }
    module.exports = createBaseFor;
  }
});

// ../../../node_modules/lodash/_baseFor.js
var require_baseFor = __commonJS({
  "../../../node_modules/lodash/_baseFor.js"(exports, module) {
    var createBaseFor = require_createBaseFor();
    var baseFor = createBaseFor();
    module.exports = baseFor;
  }
});

// ../../../node_modules/lodash/_cloneBuffer.js
var require_cloneBuffer = __commonJS({
  "../../../node_modules/lodash/_cloneBuffer.js"(exports, module) {
    var root = require_root();
    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
    var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var Buffer = moduleExports ? root.Buffer : void 0;
    var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
    function cloneBuffer(buffer, isDeep) {
      if (isDeep) {
        return buffer.slice();
      }
      var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
      buffer.copy(result);
      return result;
    }
    module.exports = cloneBuffer;
  }
});

// ../../../node_modules/lodash/_cloneArrayBuffer.js
var require_cloneArrayBuffer = __commonJS({
  "../../../node_modules/lodash/_cloneArrayBuffer.js"(exports, module) {
    var Uint8Array = require_Uint8Array();
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array(result).set(new Uint8Array(arrayBuffer));
      return result;
    }
    module.exports = cloneArrayBuffer;
  }
});

// ../../../node_modules/lodash/_cloneTypedArray.js
var require_cloneTypedArray = __commonJS({
  "../../../node_modules/lodash/_cloneTypedArray.js"(exports, module) {
    var cloneArrayBuffer = require_cloneArrayBuffer();
    function cloneTypedArray(typedArray, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
    }
    module.exports = cloneTypedArray;
  }
});

// ../../../node_modules/lodash/_copyArray.js
var require_copyArray = __commonJS({
  "../../../node_modules/lodash/_copyArray.js"(exports, module) {
    function copyArray(source, array2) {
      var index = -1, length = source.length;
      array2 || (array2 = Array(length));
      while (++index < length) {
        array2[index] = source[index];
      }
      return array2;
    }
    module.exports = copyArray;
  }
});

// ../../../node_modules/lodash/_baseCreate.js
var require_baseCreate = __commonJS({
  "../../../node_modules/lodash/_baseCreate.js"(exports, module) {
    var isObject = require_isObject();
    var objectCreate = Object.create;
    var baseCreate = function() {
      function object2() {
      }
      return function(proto) {
        if (!isObject(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object2.prototype = proto;
        var result = new object2();
        object2.prototype = void 0;
        return result;
      };
    }();
    module.exports = baseCreate;
  }
});

// ../../../node_modules/lodash/_getPrototype.js
var require_getPrototype = __commonJS({
  "../../../node_modules/lodash/_getPrototype.js"(exports, module) {
    var overArg = require_overArg();
    var getPrototype = overArg(Object.getPrototypeOf, Object);
    module.exports = getPrototype;
  }
});

// ../../../node_modules/lodash/_initCloneObject.js
var require_initCloneObject = __commonJS({
  "../../../node_modules/lodash/_initCloneObject.js"(exports, module) {
    var baseCreate = require_baseCreate();
    var getPrototype = require_getPrototype();
    var isPrototype = require_isPrototype();
    function initCloneObject(object2) {
      return typeof object2.constructor == "function" && !isPrototype(object2) ? baseCreate(getPrototype(object2)) : {};
    }
    module.exports = initCloneObject;
  }
});

// ../../../node_modules/lodash/isArrayLikeObject.js
var require_isArrayLikeObject = __commonJS({
  "../../../node_modules/lodash/isArrayLikeObject.js"(exports, module) {
    var isArrayLike = require_isArrayLike();
    var isObjectLike = require_isObjectLike();
    function isArrayLikeObject(value) {
      return isObjectLike(value) && isArrayLike(value);
    }
    module.exports = isArrayLikeObject;
  }
});

// ../../../node_modules/lodash/isPlainObject.js
var require_isPlainObject = __commonJS({
  "../../../node_modules/lodash/isPlainObject.js"(exports, module) {
    var baseGetTag = require_baseGetTag();
    var getPrototype = require_getPrototype();
    var isObjectLike = require_isObjectLike();
    var objectTag = "[object Object]";
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var funcToString = funcProto.toString;
    var hasOwnProperty = objectProto.hasOwnProperty;
    var objectCtorString = funcToString.call(Object);
    function isPlainObject(value) {
      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
    }
    module.exports = isPlainObject;
  }
});

// ../../../node_modules/lodash/_safeGet.js
var require_safeGet = __commonJS({
  "../../../node_modules/lodash/_safeGet.js"(exports, module) {
    function safeGet(object2, key) {
      if (key === "constructor" && typeof object2[key] === "function") {
        return;
      }
      if (key == "__proto__") {
        return;
      }
      return object2[key];
    }
    module.exports = safeGet;
  }
});

// ../../../node_modules/lodash/_assignValue.js
var require_assignValue = __commonJS({
  "../../../node_modules/lodash/_assignValue.js"(exports, module) {
    var baseAssignValue = require_baseAssignValue();
    var eq = require_eq();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function assignValue(object2, key, value) {
      var objValue = object2[key];
      if (!(hasOwnProperty.call(object2, key) && eq(objValue, value)) || value === void 0 && !(key in object2)) {
        baseAssignValue(object2, key, value);
      }
    }
    module.exports = assignValue;
  }
});

// ../../../node_modules/lodash/_copyObject.js
var require_copyObject = __commonJS({
  "../../../node_modules/lodash/_copyObject.js"(exports, module) {
    var assignValue = require_assignValue();
    var baseAssignValue = require_baseAssignValue();
    function copyObject(source, props, object2, customizer) {
      var isNew = !object2;
      object2 || (object2 = {});
      var index = -1, length = props.length;
      while (++index < length) {
        var key = props[index];
        var newValue = customizer ? customizer(object2[key], source[key], key, object2, source) : void 0;
        if (newValue === void 0) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object2, key, newValue);
        } else {
          assignValue(object2, key, newValue);
        }
      }
      return object2;
    }
    module.exports = copyObject;
  }
});

// ../../../node_modules/lodash/_nativeKeysIn.js
var require_nativeKeysIn = __commonJS({
  "../../../node_modules/lodash/_nativeKeysIn.js"(exports, module) {
    function nativeKeysIn(object2) {
      var result = [];
      if (object2 != null) {
        for (var key in Object(object2)) {
          result.push(key);
        }
      }
      return result;
    }
    module.exports = nativeKeysIn;
  }
});

// ../../../node_modules/lodash/_baseKeysIn.js
var require_baseKeysIn = __commonJS({
  "../../../node_modules/lodash/_baseKeysIn.js"(exports, module) {
    var isObject = require_isObject();
    var isPrototype = require_isPrototype();
    var nativeKeysIn = require_nativeKeysIn();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function baseKeysIn(object2) {
      if (!isObject(object2)) {
        return nativeKeysIn(object2);
      }
      var isProto = isPrototype(object2), result = [];
      for (var key in object2) {
        if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object2, key)))) {
          result.push(key);
        }
      }
      return result;
    }
    module.exports = baseKeysIn;
  }
});

// ../../../node_modules/lodash/keysIn.js
var require_keysIn = __commonJS({
  "../../../node_modules/lodash/keysIn.js"(exports, module) {
    var arrayLikeKeys = require_arrayLikeKeys();
    var baseKeysIn = require_baseKeysIn();
    var isArrayLike = require_isArrayLike();
    function keysIn(object2) {
      return isArrayLike(object2) ? arrayLikeKeys(object2, true) : baseKeysIn(object2);
    }
    module.exports = keysIn;
  }
});

// ../../../node_modules/lodash/toPlainObject.js
var require_toPlainObject = __commonJS({
  "../../../node_modules/lodash/toPlainObject.js"(exports, module) {
    var copyObject = require_copyObject();
    var keysIn = require_keysIn();
    function toPlainObject(value) {
      return copyObject(value, keysIn(value));
    }
    module.exports = toPlainObject;
  }
});

// ../../../node_modules/lodash/_baseMergeDeep.js
var require_baseMergeDeep = __commonJS({
  "../../../node_modules/lodash/_baseMergeDeep.js"(exports, module) {
    var assignMergeValue = require_assignMergeValue();
    var cloneBuffer = require_cloneBuffer();
    var cloneTypedArray = require_cloneTypedArray();
    var copyArray = require_copyArray();
    var initCloneObject = require_initCloneObject();
    var isArguments = require_isArguments();
    var isArray = require_isArray();
    var isArrayLikeObject = require_isArrayLikeObject();
    var isBuffer = require_isBuffer();
    var isFunction = require_isFunction();
    var isObject = require_isObject();
    var isPlainObject = require_isPlainObject();
    var isTypedArray = require_isTypedArray();
    var safeGet = require_safeGet();
    var toPlainObject = require_toPlainObject();
    function baseMergeDeep(object2, source, key, srcIndex, mergeFunc, customizer, stack) {
      var objValue = safeGet(object2, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
      if (stacked) {
        assignMergeValue(object2, key, stacked);
        return;
      }
      var newValue = customizer ? customizer(objValue, srcValue, key + "", object2, source, stack) : void 0;
      var isCommon = newValue === void 0;
      if (isCommon) {
        var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
        newValue = srcValue;
        if (isArr || isBuff || isTyped) {
          if (isArray(objValue)) {
            newValue = objValue;
          } else if (isArrayLikeObject(objValue)) {
            newValue = copyArray(objValue);
          } else if (isBuff) {
            isCommon = false;
            newValue = cloneBuffer(srcValue, true);
          } else if (isTyped) {
            isCommon = false;
            newValue = cloneTypedArray(srcValue, true);
          } else {
            newValue = [];
          }
        } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
          newValue = objValue;
          if (isArguments(objValue)) {
            newValue = toPlainObject(objValue);
          } else if (!isObject(objValue) || isFunction(objValue)) {
            newValue = initCloneObject(srcValue);
          }
        } else {
          isCommon = false;
        }
      }
      if (isCommon) {
        stack.set(srcValue, newValue);
        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
        stack["delete"](srcValue);
      }
      assignMergeValue(object2, key, newValue);
    }
    module.exports = baseMergeDeep;
  }
});

// ../../../node_modules/lodash/_baseMerge.js
var require_baseMerge = __commonJS({
  "../../../node_modules/lodash/_baseMerge.js"(exports, module) {
    var Stack = require_Stack();
    var assignMergeValue = require_assignMergeValue();
    var baseFor = require_baseFor();
    var baseMergeDeep = require_baseMergeDeep();
    var isObject = require_isObject();
    var keysIn = require_keysIn();
    var safeGet = require_safeGet();
    function baseMerge(object2, source, srcIndex, customizer, stack) {
      if (object2 === source) {
        return;
      }
      baseFor(source, function(srcValue, key) {
        stack || (stack = new Stack());
        if (isObject(srcValue)) {
          baseMergeDeep(object2, source, key, srcIndex, baseMerge, customizer, stack);
        } else {
          var newValue = customizer ? customizer(safeGet(object2, key), srcValue, key + "", object2, source, stack) : void 0;
          if (newValue === void 0) {
            newValue = srcValue;
          }
          assignMergeValue(object2, key, newValue);
        }
      }, keysIn);
    }
    module.exports = baseMerge;
  }
});

// ../../../node_modules/lodash/_apply.js
var require_apply = __commonJS({
  "../../../node_modules/lodash/_apply.js"(exports, module) {
    function apply(func, thisArg, args) {
      switch (args.length) {
        case 0:
          return func.call(thisArg);
        case 1:
          return func.call(thisArg, args[0]);
        case 2:
          return func.call(thisArg, args[0], args[1]);
        case 3:
          return func.call(thisArg, args[0], args[1], args[2]);
      }
      return func.apply(thisArg, args);
    }
    module.exports = apply;
  }
});

// ../../../node_modules/lodash/_overRest.js
var require_overRest = __commonJS({
  "../../../node_modules/lodash/_overRest.js"(exports, module) {
    var apply = require_apply();
    var nativeMax = Math.max;
    function overRest(func, start, transform) {
      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
      return function() {
        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array2 = Array(length);
        while (++index < length) {
          array2[index] = args[start + index];
        }
        index = -1;
        var otherArgs = Array(start + 1);
        while (++index < start) {
          otherArgs[index] = args[index];
        }
        otherArgs[start] = transform(array2);
        return apply(func, this, otherArgs);
      };
    }
    module.exports = overRest;
  }
});

// ../../../node_modules/lodash/constant.js
var require_constant = __commonJS({
  "../../../node_modules/lodash/constant.js"(exports, module) {
    function constant(value) {
      return function() {
        return value;
      };
    }
    module.exports = constant;
  }
});

// ../../../node_modules/lodash/_baseSetToString.js
var require_baseSetToString = __commonJS({
  "../../../node_modules/lodash/_baseSetToString.js"(exports, module) {
    var constant = require_constant();
    var defineProperty = require_defineProperty();
    var identity = require_identity();
    var baseSetToString = !defineProperty ? identity : function(func, string) {
      return defineProperty(func, "toString", {
        "configurable": true,
        "enumerable": false,
        "value": constant(string),
        "writable": true
      });
    };
    module.exports = baseSetToString;
  }
});

// ../../../node_modules/lodash/_shortOut.js
var require_shortOut = __commonJS({
  "../../../node_modules/lodash/_shortOut.js"(exports, module) {
    var HOT_COUNT = 800;
    var HOT_SPAN = 16;
    var nativeNow = Date.now;
    function shortOut(func) {
      var count = 0, lastCalled = 0;
      return function() {
        var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
        lastCalled = stamp;
        if (remaining > 0) {
          if (++count >= HOT_COUNT) {
            return arguments[0];
          }
        } else {
          count = 0;
        }
        return func.apply(void 0, arguments);
      };
    }
    module.exports = shortOut;
  }
});

// ../../../node_modules/lodash/_setToString.js
var require_setToString = __commonJS({
  "../../../node_modules/lodash/_setToString.js"(exports, module) {
    var baseSetToString = require_baseSetToString();
    var shortOut = require_shortOut();
    var setToString = shortOut(baseSetToString);
    module.exports = setToString;
  }
});

// ../../../node_modules/lodash/_baseRest.js
var require_baseRest = __commonJS({
  "../../../node_modules/lodash/_baseRest.js"(exports, module) {
    var identity = require_identity();
    var overRest = require_overRest();
    var setToString = require_setToString();
    function baseRest(func, start) {
      return setToString(overRest(func, start, identity), func + "");
    }
    module.exports = baseRest;
  }
});

// ../../../node_modules/lodash/_isIterateeCall.js
var require_isIterateeCall = __commonJS({
  "../../../node_modules/lodash/_isIterateeCall.js"(exports, module) {
    var eq = require_eq();
    var isArrayLike = require_isArrayLike();
    var isIndex = require_isIndex();
    var isObject = require_isObject();
    function isIterateeCall(value, index, object2) {
      if (!isObject(object2)) {
        return false;
      }
      var type = typeof index;
      if (type == "number" ? isArrayLike(object2) && isIndex(index, object2.length) : type == "string" && index in object2) {
        return eq(object2[index], value);
      }
      return false;
    }
    module.exports = isIterateeCall;
  }
});

// ../../../node_modules/lodash/_createAssigner.js
var require_createAssigner = __commonJS({
  "../../../node_modules/lodash/_createAssigner.js"(exports, module) {
    var baseRest = require_baseRest();
    var isIterateeCall = require_isIterateeCall();
    function createAssigner(assigner) {
      return baseRest(function(object2, sources) {
        var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
        customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
          customizer = length < 3 ? void 0 : customizer;
          length = 1;
        }
        object2 = Object(object2);
        while (++index < length) {
          var source = sources[index];
          if (source) {
            assigner(object2, source, index, customizer);
          }
        }
        return object2;
      });
    }
    module.exports = createAssigner;
  }
});

// ../../../node_modules/lodash/mergeWith.js
var require_mergeWith = __commonJS({
  "../../../node_modules/lodash/mergeWith.js"(exports, module) {
    var baseMerge = require_baseMerge();
    var createAssigner = require_createAssigner();
    var mergeWith = createAssigner(function(object2, source, srcIndex, customizer) {
      baseMerge(object2, source, srcIndex, customizer);
    });
    module.exports = mergeWith;
  }
});

// src/yup/store/form-configuration-store.ts
import { create } from "zustand";
var useYupFormConfigurationStore = create((set) => ({
  yupFormConfigurations: [],
  formConfigurationLoaded: false,
  set: (yupFormConfigurations) => set((state) => __spreadProps(__spreadValues({}, state), {
    yupFormConfigurations
  })),
  add: (yupFormConfigurations) => set((state) => ({
    yupFormConfigurations: [...state.yupFormConfigurations, __spreadValues({}, yupFormConfigurations)]
  })),
  remove: (yupFormConfigurations) => set((state) => ({
    yupFormConfigurations: state.yupFormConfigurations.filter((currentFormConfiguration) => currentFormConfiguration !== yupFormConfigurations)
  })),
  setFormConfigurationLoaded: (formConfigurationLoaded) => set((state) => __spreadProps(__spreadValues({}, state), { formConfigurationLoaded }))
}));

// src/yup/hook/use-form-configuration.ts
var useFormConfiguration = () => {
  const formYupConfigurations = useYupFormConfigurationStore((state) => state.yupFormConfigurations);
  const formConfigurationLoaded = useYupFormConfigurationStore((state) => state.formConfigurationLoaded);
  const set = useYupFormConfigurationStore((state) => state.set);
  const add = useYupFormConfigurationStore((state) => state.add);
  const remove = useYupFormConfigurationStore((state) => state.remove);
  const setFormConfigurationLoaded = useYupFormConfigurationStore((state) => state.setFormConfigurationLoaded);
  return {
    formYupConfigurations,
    formConfigurationLoaded,
    set,
    add,
    remove,
    setFormConfigurationLoaded
  };
};
var useYupFormConfiguration = (formId) => {
  const { formYupConfigurations } = useFormConfiguration();
  const searchedFormConfiguration = formYupConfigurations.find((formYupConfiguration) => formYupConfiguration.formId === formId);
  if (!searchedFormConfiguration) {
    return void 0;
  }
  return searchedFormConfiguration.yupSchema;
};

// src/yup/component/FormConfigurationProvider.tsx
import React, { useEffect } from "react";

// src/yup/loader/fetch-form-configurations.ts
var import_uniqBy = __toESM(require_uniqBy());

// src/yup/converter/FormConfigurationValidationYupConverter.ts
var import_mergeWith = __toESM(require_mergeWith());
import * as yup from "yup";
var _FormConfigurationValidationYupConverter = class {
  constructor(additionalConverters = []) {
    this.additionalConverters = additionalConverters;
  }
  /**
   * Converts {@link ConstrainedPropertyConfiguration} array to Yup's schema using builtin and provided converters.
   * @param constrainedPropertyConfigurationList array of {@link ConstrainedPropertyConfiguration} to convert
   */
  convertFormConfigurationToYupSchema(constrainedPropertyConfigurationList) {
    return this.convertFormConfigurationToYupSchemaInternal(constrainedPropertyConfigurationList);
  }
  convertFormConfigurationToYupSchemaInternal(constrainedPropertyConfigurationList) {
    let schema = yup.object().shape({});
    constrainedPropertyConfigurationList.forEach((property) => {
      const yupValidation = yup[property.javascriptType];
      if (!yupValidation) {
        return;
      }
      const validator = property.validatorList.reduce((previousValidator, validatorConfiguration) => this.applyConverter(validatorConfiguration, previousValidator), yupValidation().default(void 0).nullable());
      const [propertyName, restOfPathList] = _FormConfigurationValidationYupConverter.convertPath(property.path);
      if (restOfPathList.length > 0) {
        const currentPathSchema = [...restOfPathList].reverse().reduce((currentShape, path) => ({ [path]: yup.object().shape(currentShape).default(void 0).nullable() }), { [propertyName]: validator });
        schema = this.mergeSchemas(schema, yup.object().shape(currentPathSchema));
      } else {
        const currentPropertySchema = yup.object().shape({ [propertyName]: validator });
        schema = schema.concat(currentPropertySchema);
      }
    });
    return schema;
  }
  // Function to recursively merge two Yup schemas
  mergeSchemas(schema1, schema2) {
    const mergeObjects = (obj1, obj2) => {
      const merged = __spreadValues({}, obj1);
      Object.keys(obj2).forEach((key) => {
        if (Object.prototype.hasOwnProperty.call(merged, key)) {
          if (obj1[key].type === "object" && obj2[key].type === "object") {
            merged[key] = this.mergeSchemas(obj1[key], obj2[key]);
            merged[key].spec = (0, import_mergeWith.default)(obj1[key].spec, obj2[key].spec, (field1, field2) => typeof field1 === "boolean" ? field1 && field2 : field1 != null ? field1 : field2);
            merged[key].internalTests = __spreadValues(__spreadValues({}, obj1[key].internalTests), obj2[key].internalTests);
          } else if (obj1[key].type === "array" && obj2[key].type === "array") {
            if (obj1[key].innerType.type === "object" && obj2[key].innerType.type === "object") {
              merged[key] = yup.array().of(this.mergeSchemas(obj1[key].innerType, obj2[key].innerType));
            } else {
              merged[key] = yup.array().of(obj2[key].innerType);
            }
          } else {
            merged[key] = obj2[key];
          }
        } else {
          merged[key] = obj2[key];
        }
      });
      return merged;
    };
    const fields1 = schema1.fields;
    const fields2 = schema2.fields;
    const mergedFields = mergeObjects(fields1, fields2);
    return yup.object().shape(mergedFields);
  }
  applyConverter(validatorConfiguration, validator) {
    const converter = this.resolveConverter(validatorConfiguration);
    let resolvedValidator = validator;
    if (converter) {
      try {
        resolvedValidator = converter.convert(validatorConfiguration, validator);
      } catch (ignore) {
      }
    }
    return resolvedValidator;
  }
  resolveConverter(validatorConfiguration) {
    const allConverters = this.additionalConverters.concat(_FormConfigurationValidationYupConverter.DEFAULT_CONVERTER_LIST);
    return allConverters.find((additionalConverter) => additionalConverter.supports(validatorConfiguration));
  }
  static convertPath(path) {
    const pathList = path.split(this.PATH_SEPARATOR);
    const propertyName = pathList[pathList.length - 1];
    pathList.pop();
    return [propertyName, pathList];
  }
};
var FormConfigurationValidationYupConverter = _FormConfigurationValidationYupConverter;
FormConfigurationValidationYupConverter.PATH_SEPARATOR = ".";
FormConfigurationValidationYupConverter.DEFAULT_CONVERTER_LIST = [
  {
    supports: (configuration) => ["NotNull", "NotBlank", "NotEmpty"].includes(configuration.name),
    convert: (configuration, validator) => validator.required(configuration.errorMessage)
  },
  {
    supports: (configuration) => ["Size", "Length"].includes(configuration.name),
    convert: (configuration, validator) => validator.min(configuration.argumentMap.min, configuration.errorMessage).max(configuration.argumentMap.max, configuration.errorMessage)
  },
  {
    supports: (configuration) => ["Pattern"].includes(configuration.name),
    convert: (configuration, validator) => validator.matches(configuration.argumentMap.pattern, configuration.errorMessage)
  },
  {
    supports: (configuration) => ["Min", "Max"].includes(configuration.name),
    convert: (configuration, validator) => validator[configuration.name.toLowerCase()](configuration.argumentMap.value, configuration.errorMessage)
  },
  {
    supports: (configuration) => ["InList"].includes(configuration.name),
    convert: (configuration, validator) => validator.test("inList", configuration.errorMessage, (value) => configuration.argumentMap.value.includes(value))
  },
  {
    supports: () => true,
    convert: (configuration, validator) => validator[configuration.name.toLowerCase()](configuration.errorMessage)
  }
];

// src/yup/loader/fetch-form-configurations.ts
var mergeYupFormConfigurationsWithoutDuplicates = (oldFormConfiguration, newFormConfiguration) => {
  const mergedYupFormConfigurations = [...oldFormConfiguration, ...newFormConfiguration];
  return (0, import_uniqBy.default)(mergedYupFormConfigurations, "formId");
};
var fetchFormConfigurations = (_0) => __async(void 0, [_0], function* ({ url, requestOptionsResolver, additionalValidatorConverters }) {
  const formConfigurationValidationConverter = new FormConfigurationValidationYupConverter(additionalValidatorConverters);
  const additionalOptions = (requestOptionsResolver == null ? void 0 : requestOptionsResolver()) || {};
  const finalUrl = url || "/nrich/form/configuration";
  const response = yield fetch(`${finalUrl}/fetch-all`, __spreadValues({
    method: "POST"
  }, additionalOptions));
  const body = yield response.json();
  const formYupConfigurations = [];
  if (response.ok) {
    body.forEach((item) => {
      formYupConfigurations.push({
        formId: item.formId,
        yupSchema: formConfigurationValidationConverter.convertFormConfigurationToYupSchema(item.constrainedPropertyConfigurationList)
      });
    });
    useYupFormConfigurationStore.getState().set(mergeYupFormConfigurationsWithoutDuplicates(useYupFormConfigurationStore.getState().yupFormConfigurations, formYupConfigurations));
    useYupFormConfigurationStore.getState().setFormConfigurationLoaded(true);
  }
  return body;
});

// src/yup/component/FormConfigurationProvider.tsx
var FormConfigurationProvider = (_a) => {
  var _b = _a, { children, loader } = _b, fetchProps = __objRest(_b, ["children", "loader"]);
  useEffect(() => {
    fetchFormConfigurations(__spreadValues({}, fetchProps));
  }, []);
  const { formConfigurationLoaded } = useFormConfiguration();
  return /* @__PURE__ */ React.createElement("div", null, formConfigurationLoaded ? children : loader != null ? loader : null);
};
export {
  FormConfigurationProvider,
  useFormConfiguration,
  useYupFormConfiguration
};
//# sourceMappingURL=index.mjs.map