@conform-to/valibot 0.0.1

package/dist/coercion.mjs

@@ -0,0 +1,441 @@
+import { objectSpread2 as _objectSpread2 } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { pipeAsync, pipe, unknown, transform } from 'valibot';
+
+/**
+ * Reconstruct the provided schema with additional preprocessing steps
+ * This coerce empty values to undefined and transform strings to the correct type
+ * @param type The schema to be coerced
+ * @param transform The transformation function
+ * @returns The transform action and the coerced schema
+ */
+function coerce(type, transformFn) {
+  // `expects` is required to generate error messages for `TupleSchema`, so it is passed to `UnknownSchema` for coercion.
+  var unknown$1 = _objectSpread2(_objectSpread2({}, unknown()), {}, {
+    expects: type.expects
+  });
+  var transformAction = transform(transformFn);
+  var schema = type.async ? pipeAsync(unknown$1, transformAction, type) : pipe(unknown$1, transformAction, type);
+  return {
+    transformAction,
+    schema
+  };
+}
+
+/**
+ * Strip empty strings and convert them to undefined.
+ *
+ * @param value The value to be checked and coerced.
+ * @returns The coerced value or undefined if the input is an empty string.
+ */
+function stripEmptyString(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  if (value === '') {
+    return undefined;
+  }
+  return value;
+}
+
+/**
+ * Strip empty files and convert them to undefined.
+ *
+ * @param file The file to be checked and coerced.
+ * @returns The coerced value or undefined if the input is an empty file.
+ */
+function stripEmptyFile(file) {
+  if (typeof File !== 'undefined' && file instanceof File && file.name === '' && file.size === 0) {
+    return undefined;
+  }
+  return file;
+}
+
+/**
+ * Helpers for coercing number value
+ * Modify the value only if it's a string, otherwise return the value as-is
+ */
+function coerceNumber(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  return value.trim() === '' ? value : Number(value);
+}
+
+/**
+ * Helpers for coercing boolean value
+ * Modify the value only if it's a string, otherwise return the value as-is
+ */
+function coerceBoolean(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  return value === 'on' ? true : value;
+}
+
+/**
+ * Helpers for coercing date value
+ * Modify the value only if it's a string, otherwise return the value as-is
+ */
+function coerceDate(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  var date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date;
+}
+
+/**
+ * Helpers for coercing bigint value
+ * Modify the value only if it's a string, otherwise return the value as-is
+ */
+function coerceBigInt(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  if (value.trim() === '') {
+    return value;
+  }
+  try {
+    return BigInt(value);
+  } catch (_unused) {
+    return value;
+  }
+}
+
+/**
+ * Helpers for coercing array value
+ * Modify the value only if it's an array, otherwise return the value as-is
+ */
+function coerceArray(type) {
+  // `expects` is required to generate error messages for `TupleSchema`, so it is passed to `UnkonwSchema` for coercion.
+  var unknown$1 = _objectSpread2(_objectSpread2({}, unknown()), {}, {
+    expects: type.expects
+  });
+  var transformFunction = output => {
+    if (Array.isArray(output)) {
+      return output;
+    }
+    if (typeof output === 'undefined' || typeof stripEmptyFile(stripEmptyString(output)) === 'undefined') {
+      return [];
+    }
+    return [output];
+  };
+  if (type.async) {
+    return pipeAsync(unknown$1, transform(transformFunction), type);
+  }
+  return pipe(unknown$1, transform(transformFunction), type);
+}
+
+/**
+ * Compose two coercion functions
+ * @param a The first coercion function
+ * @param b The second coercion function
+ * @returns The composed coercion function
+ */
+function compose(a, b) {
+  return value => b(a(value));
+}
+
+/**
+ * Generate a wrapped schema with coercion
+ * @param type The schema to be coerced
+ * @param options The options for coercion
+ * @param rewrap Whether the result schema should be rewrapped with the `type` schema.
+ *   See <https://github.com/chimame/conform-to-valibot/issues/53> for cases that need rewrapping.
+ * @returns The coerced schema
+ */
+function generateWrappedSchema(type, options) {
+  var rewrap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var {
+    transformAction,
+    schema: wrapSchema
+  } = enableTypeCoercion(
+  // @ts-expect-error
+  type.wrapped, options);
+  if (transformAction) {
+    // `expects` is required to generate error messages for `TupleSchema`, so it is passed to `UnkonwSchema` for coercion.
+    var unknown$1 = _objectSpread2(_objectSpread2({}, unknown()), {}, {
+      expects: type.expects
+    });
+    var schema = type.async ? pipeAsync(unknown$1, transformAction, type) : pipe(unknown$1, transformAction, type);
+    var default_ = 'default' in type ? type.default : undefined;
+    if (rewrap) {
+      return {
+        transformAction: undefined,
+        schema: type.reference(schema, default_)
+      };
+    }
+    return {
+      transformAction,
+      schema
+    };
+  }
+  var wrappedSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+    wrapped: wrapSchema
+  });
+  return {
+    transformAction: undefined,
+    schema: wrappedSchema
+  };
+}
+
+/**
+ * Reconstruct the provided schema with additional preprocessing steps
+ * This coerce empty values to undefined and transform strings to the correct type
+ */
+
+function enableTypeCoercion(type, options) {
+  if ('pipe' in type) {
+    var {
+      transformAction,
+      schema: coercedSchema
+    } = enableTypeCoercion(type.pipe[0], options);
+    var schema = type.async ? pipeAsync(coercedSchema, ...type.pipe.slice(1)) :
+    // @ts-expect-error `coercedSchema` must be sync here but TypeScript can't infer that.
+    pipe(coercedSchema, ...type.pipe.slice(1));
+    return {
+      transformAction,
+      schema
+    };
+  }
+  var defineCoercionFn = options.defineCoercion(type);
+  if (defineCoercionFn) {
+    return coerce(type, defineCoercionFn);
+  }
+  switch (type.type) {
+    case 'string':
+    case 'literal':
+    case 'enum':
+    case 'undefined':
+      {
+        return coerce(type, options.defaultCoercion.string);
+      }
+    case 'number':
+      {
+        return coerce(type, options.defaultCoercion.number);
+      }
+    case 'boolean':
+      {
+        return coerce(type, options.defaultCoercion.boolean);
+      }
+    case 'date':
+      {
+        return coerce(type, options.defaultCoercion.date);
+      }
+    case 'bigint':
+      {
+        return coerce(type, options.defaultCoercion.bigint);
+      }
+    case 'file':
+    case 'blob':
+      {
+        return coerce(type, options.defaultCoercion.file);
+      }
+    case 'array':
+      {
+        var arraySchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          // @ts-expect-error
+          item: enableTypeCoercion(type.item, options).schema
+        });
+        return {
+          transformAction: undefined,
+          schema: coerceArray(arraySchema)
+        };
+      }
+    case 'exact_optional':
+      {
+        // @ts-expect-error
+        var {
+          schema: wrapSchema
+        } = enableTypeCoercion(type.wrapped, options);
+        var exactOptionalSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          wrapped: wrapSchema
+        });
+        return {
+          transformAction: undefined,
+          schema: exactOptionalSchema
+        };
+      }
+    case 'nullish':
+    case 'optional':
+      {
+        return generateWrappedSchema(type, options, true);
+      }
+    case 'undefinedable':
+    case 'nullable':
+    case 'non_optional':
+    case 'non_nullish':
+    case 'non_nullable':
+      {
+        return generateWrappedSchema(type, options);
+      }
+    case 'union':
+    case 'intersect':
+      {
+        var unionSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          // @ts-expect-error
+          options: type.options.map(
+          // @ts-expect-error
+          option => enableTypeCoercion(option, options).schema)
+        });
+        return {
+          transformAction: undefined,
+          schema: unionSchema
+        };
+      }
+    case 'variant':
+      {
+        var variantSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          // @ts-expect-error
+          options: type.options.map(
+          // @ts-expect-error
+          option => enableTypeCoercion(option, options).schema)
+        });
+        return {
+          transformAction: undefined,
+          schema: variantSchema
+        };
+      }
+    case 'tuple':
+      {
+        var tupleSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          // @ts-expect-error
+          items: type.items.map(
+          // @ts-expect-error
+          option => enableTypeCoercion(option, options).schema)
+        });
+        return {
+          transformAction: undefined,
+          schema: tupleSchema
+        };
+      }
+    case 'tuple_with_rest':
+      {
+        var tupleWithRestSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          // @ts-expect-error
+          items: type.items.map(
+          // @ts-expect-error
+          option => enableTypeCoercion(option, options).schema),
+          // @ts-expect-error
+          rest: enableTypeCoercion(type.rest, options).schema
+        });
+        return {
+          transformAction: undefined,
+          schema: tupleWithRestSchema
+        };
+      }
+    case 'loose_object':
+    case 'strict_object':
+    case 'object':
+      {
+        var objectSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          entries: Object.fromEntries(
+          // @ts-expect-error
+          Object.entries(type.entries).map(_ref => {
+            var [key, def] = _ref;
+            return [key, enableTypeCoercion(def, options).schema];
+          }))
+        });
+        return {
+          transformAction: undefined,
+          schema: objectSchema
+        };
+      }
+    case 'object_with_rest':
+      {
+        var objectWithRestSchema = _objectSpread2(_objectSpread2({}, type), {}, {
+          entries: Object.fromEntries(
+          // @ts-expect-error
+          Object.entries(type.entries).map(_ref2 => {
+            var [key, def] = _ref2;
+            return [key, enableTypeCoercion(def, options).schema];
+          })),
+          // @ts-expect-error
+          rest: enableTypeCoercion(type.rest, options).schema
+        });
+        return {
+          transformAction: undefined,
+          schema: objectWithRestSchema
+        };
+      }
+  }
+  return coerce(type, value => value);
+}
+
+/**
+ * A helper that enhance the valibot schema to strip empty value and coerce form value to the expected type with option to customize type coercion.
+ * @example
+ *
+ * ```tsx
+ * import { parseWithValibot, unstable_coerceFormValue as coerceFormValue } from '@conform-to/valibot';
+ * import { object, number, date, boolean } from 'valibot';
+ *
+ * // To coerce the form value with default behaviour
+ * const schema = coerceFormValue(
+ *   object({
+ *     ref: number(),
+ *     date: date(),
+ *     amount: number(),
+ *     confirm: boolean(),
+ *   })
+ * );
+ *
+ * // To coerce the form value with number type disabled
+ * const schema = coerceFormValue(
+ *   object({
+ *     ref: number(),
+ *     date: date(),
+ *     amount: number(),
+ *     confirm: boolean(),
+ *   }),
+ *   {
+ *     defaultCoercion: {
+ *       number: false,
+ *     },
+ *     defineCoercion: (schema) => {
+ *       if (schema.type === 'string') {
+ *         return (value) => value.trim();
+ *       }
+ *       return null;
+ *     },
+ *   },
+ * );
+ * ```
+ */
+function coerceFormValue(type, options) {
+  var _options$defaultCoerc, _options$defaultCoerc2, _options$defaultCoerc3, _options$defaultCoerc4, _options$defaultCoerc5, _options$defaultCoerc6, _options$defineCoerci;
+  return enableTypeCoercion(type, {
+    defaultCoercion: {
+      string: compose(stripEmptyString, getCoercion(options === null || options === void 0 || (_options$defaultCoerc = options.defaultCoercion) === null || _options$defaultCoerc === void 0 ? void 0 : _options$defaultCoerc.string)),
+      file: compose(stripEmptyFile, getCoercion(options === null || options === void 0 || (_options$defaultCoerc2 = options.defaultCoercion) === null || _options$defaultCoerc2 === void 0 ? void 0 : _options$defaultCoerc2.file)),
+      number: compose(stripEmptyString, getCoercion(options === null || options === void 0 || (_options$defaultCoerc3 = options.defaultCoercion) === null || _options$defaultCoerc3 === void 0 ? void 0 : _options$defaultCoerc3.number, coerceNumber)),
+      boolean: compose(stripEmptyString, getCoercion(options === null || options === void 0 || (_options$defaultCoerc4 = options.defaultCoercion) === null || _options$defaultCoerc4 === void 0 ? void 0 : _options$defaultCoerc4.boolean, coerceBoolean)),
+      date: compose(stripEmptyString, getCoercion(options === null || options === void 0 || (_options$defaultCoerc5 = options.defaultCoercion) === null || _options$defaultCoerc5 === void 0 ? void 0 : _options$defaultCoerc5.date, coerceDate)),
+      bigint: compose(stripEmptyString, getCoercion(options === null || options === void 0 || (_options$defaultCoerc6 = options.defaultCoercion) === null || _options$defaultCoerc6 === void 0 ? void 0 : _options$defaultCoerc6.bigint, coerceBigInt))
+    },
+    defineCoercion: (_options$defineCoerci = options === null || options === void 0 ? void 0 : options.defineCoercion) !== null && _options$defineCoerci !== void 0 ? _options$defineCoerci : () => null
+  });
+}
+
+/**
+ * Get the coercion function from the provided coercion option
+ * @param providedCoercion The provided coercion option
+ * @param fallbackCoercion The fallback coercion function
+ * @returns The coercion function
+ */
+var getCoercion = (providedCoercion, fallbackCoercion) => {
+  if (typeof providedCoercion === 'function') {
+    return providedCoercion;
+  }
+
+  // If the user explicitly disabled the coercion or no fallback coercion, return a noop function
+  if (providedCoercion === false || fallbackCoercion === undefined) {
+    return value => value;
+  }
+  return fallbackCoercion;
+};
+
+export { coerceFormValue };

package/dist/constraint.d.ts

@@ -0,0 +1,3 @@
+import type { Constraint } from '@conform-to/dom';
+import type { GenericSchema, GenericSchemaAsync } from 'valibot';
+export declare function getValibotConstraint<T extends GenericSchema | GenericSchemaAsync>(schema: T): Record<string, Constraint>;

package/dist/constraint.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+
+var keys = ['required', 'minLength', 'maxLength', 'min', 'max', 'step', 'multiple', 'pattern'];
+function getValibotConstraint(schema) {
+  function updateConstraint(schema, data) {
+    var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    if (name !== '' && !data[name]) {
+      data[name] = {
+        required: true
+      };
+    }
+    var constraint = name !== '' ? data[name] : {};
+    if (schema.type === 'object' || schema.type === 'object_with_rest' || schema.type === 'strict_object' || schema.type === 'loose_object') {
+      // @ts-expect-error
+      for (var key in schema.entries) {
+        updateConstraint(
+        // @ts-expect-error
+        schema.entries[key], data, name !== '' ? "".concat(name, ".").concat(key) : key);
+      }
+    } else if (schema.type === 'intersect') {
+      // @ts-expect-error
+      for (var option of schema.options) {
+        var _result = {};
+        updateConstraint(option, _result, name);
+        Object.assign(data, _result);
+      }
+    } else if (schema.type === 'union' || schema.type === 'variant') {
+      Object.assign(data,
+      // @ts-expect-error
+      schema.options
+      // @ts-expect-error
+      .map(option => {
+        var result = {};
+        updateConstraint(option, result, name);
+        return result;
+      })
+      // @ts-expect-error
+      .reduce((prev, next) => {
+        var list = new Set([...Object.keys(prev), ...Object.keys(next)]);
+        var result = {};
+        for (var _name of list) {
+          var prevConstraint = prev[_name];
+          var nextConstraint = next[_name];
+          if (prevConstraint && nextConstraint) {
+            var _constraint = {};
+            result[_name] = _constraint;
+            for (var _key of keys) {
+              if (typeof prevConstraint[_key] !== 'undefined' && typeof nextConstraint[_key] !== 'undefined' && prevConstraint[_key] === nextConstraint[_key]) {
+                _constraint[_key] = prevConstraint[_key];
+              }
+            }
+          } else {
+            result[_name] = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, prevConstraint), nextConstraint), {}, {
+              required: false
+            });
+          }
+        }
+        return result;
+      }));
+    } else if (name === '') {
+      // All the cases below are not allowed on root
+      throw new Error('Unsupported schema');
+    } else if (schema.type === 'array') {
+      constraint.multiple = true;
+      // @ts-expect-error
+      updateConstraint(schema.item, data, "".concat(name, "[]"));
+    } else if (schema.type === 'string') {
+      var _schema$pipe, _schema$pipe2;
+      // @ts-expect-error
+      var minLength = (_schema$pipe = schema.pipe) === null || _schema$pipe === void 0 ? void 0 : _schema$pipe.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'min_length');
+      if (minLength && 'requirement' in minLength) {
+        constraint.minLength = minLength.requirement;
+      }
+      // @ts-expect-error
+      var maxLength = (_schema$pipe2 = schema.pipe) === null || _schema$pipe2 === void 0 ? void 0 : _schema$pipe2.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'max_length');
+      if (maxLength && 'requirement' in maxLength) {
+        constraint.maxLength = maxLength.requirement;
+      }
+    } else if (schema.type === 'optional' || schema.type === 'nullish' || schema.type === 'exact_optional') {
+      constraint.required = false;
+      // @ts-expect-error
+      updateConstraint(schema.wrapped, data, name);
+    } else if (schema.type === 'number' || schema.type === 'bigint') {
+      var _schema$pipe3, _schema$pipe4;
+      // @ts-expect-error
+      var minValue = (_schema$pipe3 = schema.pipe) === null || _schema$pipe3 === void 0 ? void 0 : _schema$pipe3.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'min_value');
+      if (minValue && 'requirement' in minValue) {
+        constraint.min = minValue.requirement;
+      }
+      // @ts-expect-error
+      var maxValue = (_schema$pipe4 = schema.pipe) === null || _schema$pipe4 === void 0 ? void 0 : _schema$pipe4.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'max_value');
+      if (maxValue && 'requirement' in maxValue) {
+        constraint.max = maxValue.requirement;
+      }
+    } else if (schema.type === 'enum') {
+      // @ts-expect-error
+      constraint.pattern = Object.entries(schema.enum).map(_ref => {
+        var [, option] = _ref;
+        return (
+          // To escape unsafe characters on regex
+          typeof option === 'string' ? option.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d') : option
+        );
+      }).join('|');
+    } else if (schema.type === 'tuple' || schema.type === 'tuple_with_rest') {
+      // @ts-expect-error
+      for (var i = 0; i < schema.items.length; i++) {
+        // @ts-expect-error
+        updateConstraint(schema.items[i], data, "".concat(name, "[").concat(i, "]"));
+      }
+    } else ;
+  }
+  var result = {};
+  updateConstraint(schema, result);
+  return result;
+}
+
+exports.getValibotConstraint = getValibotConstraint;

package/dist/constraint.mjs

@@ -0,0 +1,125 @@
+import { objectSpread2 as _objectSpread2 } from './_virtual/_rollupPluginBabelHelpers.mjs';
+
+var keys = ['required', 'minLength', 'maxLength', 'min', 'max', 'step', 'multiple', 'pattern'];
+function getValibotConstraint(schema) {
+  function updateConstraint(schema, data) {
+    var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    if (name !== '' && !data[name]) {
+      data[name] = {
+        required: true
+      };
+    }
+    var constraint = name !== '' ? data[name] : {};
+    if (schema.type === 'object' || schema.type === 'object_with_rest' || schema.type === 'strict_object' || schema.type === 'loose_object') {
+      // @ts-expect-error
+      for (var key in schema.entries) {
+        updateConstraint(
+        // @ts-expect-error
+        schema.entries[key], data, name !== '' ? "".concat(name, ".").concat(key) : key);
+      }
+    } else if (schema.type === 'intersect') {
+      // @ts-expect-error
+      for (var option of schema.options) {
+        var _result = {};
+        updateConstraint(option, _result, name);
+        Object.assign(data, _result);
+      }
+    } else if (schema.type === 'union' || schema.type === 'variant') {
+      Object.assign(data,
+      // @ts-expect-error
+      schema.options
+      // @ts-expect-error
+      .map(option => {
+        var result = {};
+        updateConstraint(option, result, name);
+        return result;
+      })
+      // @ts-expect-error
+      .reduce((prev, next) => {
+        var list = new Set([...Object.keys(prev), ...Object.keys(next)]);
+        var result = {};
+        for (var _name of list) {
+          var prevConstraint = prev[_name];
+          var nextConstraint = next[_name];
+          if (prevConstraint && nextConstraint) {
+            var _constraint = {};
+            result[_name] = _constraint;
+            for (var _key of keys) {
+              if (typeof prevConstraint[_key] !== 'undefined' && typeof nextConstraint[_key] !== 'undefined' && prevConstraint[_key] === nextConstraint[_key]) {
+                _constraint[_key] = prevConstraint[_key];
+              }
+            }
+          } else {
+            result[_name] = _objectSpread2(_objectSpread2(_objectSpread2({}, prevConstraint), nextConstraint), {}, {
+              required: false
+            });
+          }
+        }
+        return result;
+      }));
+    } else if (name === '') {
+      // All the cases below are not allowed on root
+      throw new Error('Unsupported schema');
+    } else if (schema.type === 'array') {
+      constraint.multiple = true;
+      // @ts-expect-error
+      updateConstraint(schema.item, data, "".concat(name, "[]"));
+    } else if (schema.type === 'string') {
+      var _schema$pipe, _schema$pipe2;
+      // @ts-expect-error
+      var minLength = (_schema$pipe = schema.pipe) === null || _schema$pipe === void 0 ? void 0 : _schema$pipe.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'min_length');
+      if (minLength && 'requirement' in minLength) {
+        constraint.minLength = minLength.requirement;
+      }
+      // @ts-expect-error
+      var maxLength = (_schema$pipe2 = schema.pipe) === null || _schema$pipe2 === void 0 ? void 0 : _schema$pipe2.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'max_length');
+      if (maxLength && 'requirement' in maxLength) {
+        constraint.maxLength = maxLength.requirement;
+      }
+    } else if (schema.type === 'optional' || schema.type === 'nullish' || schema.type === 'exact_optional') {
+      constraint.required = false;
+      // @ts-expect-error
+      updateConstraint(schema.wrapped, data, name);
+    } else if (schema.type === 'number' || schema.type === 'bigint') {
+      var _schema$pipe3, _schema$pipe4;
+      // @ts-expect-error
+      var minValue = (_schema$pipe3 = schema.pipe) === null || _schema$pipe3 === void 0 ? void 0 : _schema$pipe3.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'min_value');
+      if (minValue && 'requirement' in minValue) {
+        constraint.min = minValue.requirement;
+      }
+      // @ts-expect-error
+      var maxValue = (_schema$pipe4 = schema.pipe) === null || _schema$pipe4 === void 0 ? void 0 : _schema$pipe4.find(
+      // @ts-expect-error
+      v => 'type' in v && v.type === 'max_value');
+      if (maxValue && 'requirement' in maxValue) {
+        constraint.max = maxValue.requirement;
+      }
+    } else if (schema.type === 'enum') {
+      // @ts-expect-error
+      constraint.pattern = Object.entries(schema.enum).map(_ref => {
+        var [, option] = _ref;
+        return (
+          // To escape unsafe characters on regex
+          typeof option === 'string' ? option.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d') : option
+        );
+      }).join('|');
+    } else if (schema.type === 'tuple' || schema.type === 'tuple_with_rest') {
+      // @ts-expect-error
+      for (var i = 0; i < schema.items.length; i++) {
+        // @ts-expect-error
+        updateConstraint(schema.items[i], data, "".concat(name, "[").concat(i, "]"));
+      }
+    } else ;
+  }
+  var result = {};
+  updateConstraint(schema, result);
+  return result;
+}
+
+export { getValibotConstraint };