@conform-to/valibot 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Edmund Hung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+exports.defineProperty = _defineProperty;
+exports.objectSpread2 = _objectSpread2;
+exports.toPrimitive = _toPrimitive;
+exports.toPropertyKey = _toPropertyKey;

package/dist/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,51 @@
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+export { _defineProperty as defineProperty, _objectSpread2 as objectSpread2, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey };

package/dist/coercion.d.ts

@@ -0,0 +1,62 @@
+import { type GenericSchema, type GenericSchemaAsync, type TransformAction } from 'valibot';
+export type CoercionFunction = (value: unknown) => unknown;
+export type DefaultCoercionType = 'string' | 'file' | 'number' | 'boolean' | 'date' | 'bigint';
+type EnableTypeCoercionOptions = {
+    defaultCoercion: Record<DefaultCoercionType, CoercionFunction>;
+    defineCoercion: (type: GenericSchema | GenericSchemaAsync) => CoercionFunction | null;
+};
+/**
+ * Reconstruct the provided schema with additional preprocessing steps
+ * This coerce empty values to undefined and transform strings to the correct type
+ */
+declare function enableTypeCoercion<T extends GenericSchema | GenericSchemaAsync>(type: T, options: EnableTypeCoercionOptions): {
+    transformAction: TransformAction<unknown, unknown> | undefined;
+    schema: T extends GenericSchema<unknown, infer Output, infer Issue> ? GenericSchema<unknown, Output, Issue> : T extends GenericSchemaAsync<unknown, infer OutputAsync, infer IssueAsync> ? GenericSchemaAsync<unknown, OutputAsync, IssueAsync> : never;
+};
+/**
+ * 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;
+ *     },
+ *   },
+ * );
+ * ```
+ */
+export declare function coerceFormValue<T extends GenericSchema | GenericSchemaAsync>(type: T, options?: {
+    defaultCoercion?: {
+        [key in DefaultCoercionType]?: CoercionFunction | boolean;
+    };
+    defineCoercion?: (type: GenericSchema | GenericSchemaAsync) => CoercionFunction | null;
+}): ReturnType<typeof enableTypeCoercion>;
+export {};

package/dist/coercion.js

@@ -0,0 +1,445 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var valibot = require('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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, valibot.unknown()), {}, {
+    expects: type.expects
+  });
+  var transformAction = valibot.transform(transformFn);
+  var schema = type.async ? valibot.pipeAsync(unknown, transformAction, type) : valibot.pipe(unknown, 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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, valibot.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 valibot.pipeAsync(unknown, valibot.transform(transformFunction), type);
+  }
+  return valibot.pipe(unknown, valibot.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, valibot.unknown()), {}, {
+      expects: type.expects
+    });
+    var schema = type.async ? valibot.pipeAsync(unknown, transformAction, type) : valibot.pipe(unknown, 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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 ? valibot.pipeAsync(coercedSchema, ...type.pipe.slice(1)) :
+    // @ts-expect-error `coercedSchema` must be sync here but TypeScript can't infer that.
+    valibot.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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 = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.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;
+};
+
+exports.coerceFormValue = coerceFormValue;